@pezkuwi/extension-base 0.62.10 → 0.62.12

package/background/handlers/Extension.js

@@ -1,64 +1,3 @@
-// Copyright 2019-2025 @pezkuwi/extension-base 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 _Extension_cachedUnlocks, _Extension_state;
 import { ALLOWED_PATH, PASSWORD_EXPIRY_MS } from '@pezkuwi/extension-base/defaults';
 import { metadataExpand } from '@pezkuwi/extension-chains';
 import { TypeRegistry } from '@pezkuwi/types';
@@ -68,49 +7,46 @@ import { assert, isHex } from '@pezkuwi/util';
 import { keyExtractSuri, mnemonicGenerate, mnemonicValidate } from '@pezkuwi/util-crypto';
 import { withErrorLog } from './helpers.js';
 import { createSubscription, unsubscribe } from './subscriptions.js';
-var SEED_DEFAULT_LENGTH = 12;
-var SEED_LENGTHS = [12, 15, 18, 21, 24];
-var ETH_DERIVE_DEFAULT = "/m/44'/60'/0'/0/0";
+const SEED_DEFAULT_LENGTH = 12;
+const SEED_LENGTHS = [12, 15, 18, 21, 24];
+const ETH_DERIVE_DEFAULT = "/m/44'/60'/0'/0/0";
 function getSuri(seed, type) {
     return type === 'ethereum'
-        ? "".concat(seed).concat(ETH_DERIVE_DEFAULT)
+        ? `${seed}${ETH_DERIVE_DEFAULT}`
         : seed;
 }
 function isJsonPayload(value) {
     return value.genesisHash !== undefined;
 }
-var Extension = /** @class */ (function () {
-    function Extension(state) {
-        _Extension_cachedUnlocks.set(this, void 0);
-        _Extension_state.set(this, void 0);
-        __classPrivateFieldSet(this, _Extension_cachedUnlocks, {}, "f");
-        __classPrivateFieldSet(this, _Extension_state, state, "f");
-    }
-    Extension.prototype.transformAccounts = function (accounts) {
-        var _this = this;
-        return Object.values(accounts).map(function (_a) {
-            var _b = _a.json, address = _b.address, meta = _b.meta, type = _a.type;
-            return (__assign(__assign({ address: address, isDefaultAuthSelected: __classPrivateFieldGet(_this, _Extension_state, "f").defaultAuthAccountSelection.includes(address) }, meta), { type: type }));
-        });
-    };
-    Extension.prototype.accountsCreateExternal = function (_a) {
-        var address = _a.address, genesisHash = _a.genesisHash, name = _a.name;
-        keyring.addExternal(address, { genesisHash: genesisHash, name: name });
+export default class Extension {
+    #cachedUnlocks;
+    #state;
+    constructor(state) {
+        this.#cachedUnlocks = {};
+        this.#state = state;
+    }
+    transformAccounts(accounts) {
+        return Object.values(accounts).map(({ json: { address, meta }, type }) => ({
+            address,
+            isDefaultAuthSelected: this.#state.defaultAuthAccountSelection.includes(address),
+            ...meta,
+            type
+        }));
+    }
+    accountsCreateExternal({ address, genesisHash, name }) {
+        keyring.addExternal(address, { genesisHash, name });
         return true;
-    };
-    Extension.prototype.accountsCreateHardware = function (_a) {
-        var accountIndex = _a.accountIndex, address = _a.address, addressOffset = _a.addressOffset, genesisHash = _a.genesisHash, hardwareType = _a.hardwareType, name = _a.name, type = _a.type;
-        keyring.addHardware(address, hardwareType, { accountIndex: accountIndex, addressOffset: addressOffset, genesisHash: genesisHash, name: name, type: type });
+    }
+    accountsCreateHardware({ accountIndex, address, addressOffset, genesisHash, hardwareType, name, type }) {
+        keyring.addHardware(address, hardwareType, { accountIndex, addressOffset, genesisHash, name, type });
         return true;
-    };
-    Extension.prototype.accountsCreateSuri = function (_a) {
-        var genesisHash = _a.genesisHash, name = _a.name, password = _a.password, suri = _a.suri, type = _a.type;
-        keyring.addUri(getSuri(suri, type), password, { genesisHash: genesisHash, name: name }, type);
+    }
+    accountsCreateSuri({ genesisHash, name, password, suri, type }) {
+        keyring.addUri(getSuri(suri, type), password, { genesisHash, name }, type);
         return true;
-    };
-    Extension.prototype.accountsChangePassword = function (_a) {
-        var address = _a.address, newPass = _a.newPass, oldPass = _a.oldPass;
-        var pair = keyring.getPair(address);
+    }
+    accountsChangePassword({ address, newPass, oldPass }) {
+        const pair = keyring.getPair(address);
         assert(pair, 'Unable to find pair');
         try {
             if (!pair.isLocked) {
@@ -118,257 +54,195 @@ var Extension = /** @class */ (function () {
             }
             pair.decodePkcs8(oldPass);
         }
-        catch (_b) {
+        catch {
             throw new Error('oldPass is invalid');
         }
         keyring.encryptAccount(pair, newPass);
         return true;
-    };
-    Extension.prototype.accountsEdit = function (_a) {
-        var address = _a.address, name = _a.name;
-        var pair = keyring.getPair(address);
+    }
+    accountsEdit({ address, name }) {
+        const pair = keyring.getPair(address);
         assert(pair, 'Unable to find pair');
-        keyring.saveAccountMeta(pair, __assign(__assign({}, pair.meta), { name: name }));
+        keyring.saveAccountMeta(pair, { ...pair.meta, name });
         return true;
-    };
-    Extension.prototype.accountsExport = function (_a) {
-        var address = _a.address, password = _a.password;
+    }
+    accountsExport({ address, password }) {
         return { exportedJson: keyring.backupAccount(keyring.getPair(address), password) };
-    };
-    Extension.prototype.accountsBatchExport = function (_a) {
-        return __awaiter(this, arguments, void 0, function (_b) {
-            var _c;
-            var addresses = _b.addresses, password = _b.password;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        _c = {};
-                        return [4 /*yield*/, keyring.backupAccounts(addresses, password)];
-                    case 1: return [2 /*return*/, (_c.exportedJson = _d.sent(),
-                            _c)];
-                }
-            });
-        });
-    };
-    Extension.prototype.accountsForget = function (_a) {
-        return __awaiter(this, arguments, void 0, function (_b) {
-            var authorizedAccountsDiff, newDefaultAuthAccounts;
-            var address = _b.address;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        authorizedAccountsDiff = [];
-                        // cycle through authUrls and prepare the array of diff
-                        Object.entries(__classPrivateFieldGet(this, _Extension_state, "f").authUrls).forEach(function (_a) {
-                            var _b;
-                            var url = _a[0], urlInfo = _a[1];
-                            // Note that urlInfo.authorizedAccounts may be undefined if this website entry
-                            // was created before the "account authorization per website" functionality was introduced
-                            if ((_b = urlInfo.authorizedAccounts) === null || _b === void 0 ? void 0 : _b.includes(address)) {
-                                authorizedAccountsDiff.push([url, urlInfo.authorizedAccounts.filter(function (previousAddress) { return previousAddress !== address; })]);
-                            }
-                        });
-                        return [4 /*yield*/, __classPrivateFieldGet(this, _Extension_state, "f").updateAuthorizedAccounts(authorizedAccountsDiff)];
-                    case 1:
-                        _c.sent();
-                        newDefaultAuthAccounts = __classPrivateFieldGet(this, _Extension_state, "f").defaultAuthAccountSelection.filter(function (defaultSelectionAddress) { return defaultSelectionAddress !== address; });
-                        return [4 /*yield*/, __classPrivateFieldGet(this, _Extension_state, "f").updateDefaultAuthAccounts(newDefaultAuthAccounts)];
-                    case 2:
-                        _c.sent();
-                        keyring.forgetAccount(address);
-                        return [2 /*return*/, true];
-                }
-            });
+    }
+    async accountsBatchExport({ addresses, password }) {
+        return {
+            exportedJson: await keyring.backupAccounts(addresses, password)
+        };
+    }
+    async accountsForget({ address }) {
+        const authorizedAccountsDiff = [];
+        // cycle through authUrls and prepare the array of diff
+        Object.entries(this.#state.authUrls).forEach(([url, urlInfo]) => {
+            // Note that urlInfo.authorizedAccounts may be undefined if this website entry
+            // was created before the "account authorization per website" functionality was introduced
+            if (urlInfo.authorizedAccounts?.includes(address)) {
+                authorizedAccountsDiff.push([url, urlInfo.authorizedAccounts.filter((previousAddress) => previousAddress !== address)]);
+            }
         });
-    };
-    Extension.prototype.refreshAccountPasswordCache = function (pair) {
-        var address = pair.address;
-        var savedExpiry = __classPrivateFieldGet(this, _Extension_cachedUnlocks, "f")[address] || 0;
-        var remainingTime = savedExpiry - Date.now();
+        await this.#state.updateAuthorizedAccounts(authorizedAccountsDiff);
+        // cycle through default account selection for auth and remove any occurrence of the account
+        const newDefaultAuthAccounts = this.#state.defaultAuthAccountSelection.filter((defaultSelectionAddress) => defaultSelectionAddress !== address);
+        await this.#state.updateDefaultAuthAccounts(newDefaultAuthAccounts);
+        keyring.forgetAccount(address);
+        return true;
+    }
+    refreshAccountPasswordCache(pair) {
+        const { address } = pair;
+        const savedExpiry = this.#cachedUnlocks[address] || 0;
+        const remainingTime = savedExpiry - Date.now();
         if (remainingTime < 0) {
-            __classPrivateFieldGet(this, _Extension_cachedUnlocks, "f")[address] = 0;
+            this.#cachedUnlocks[address] = 0;
             pair.lock();
             return 0;
         }
         return remainingTime;
-    };
-    Extension.prototype.accountsShow = function (_a) {
-        var address = _a.address, isShowing = _a.isShowing;
-        var pair = keyring.getPair(address);
+    }
+    accountsShow({ address, isShowing }) {
+        const pair = keyring.getPair(address);
         assert(pair, 'Unable to find pair');
-        keyring.saveAccountMeta(pair, __assign(__assign({}, pair.meta), { isHidden: !isShowing }));
+        keyring.saveAccountMeta(pair, { ...pair.meta, isHidden: !isShowing });
         return true;
-    };
-    Extension.prototype.accountsTie = function (_a) {
-        var address = _a.address, genesisHash = _a.genesisHash;
-        var pair = keyring.getPair(address);
+    }
+    accountsTie({ address, genesisHash }) {
+        const pair = keyring.getPair(address);
         assert(pair, 'Unable to find pair');
-        keyring.saveAccountMeta(pair, __assign(__assign({}, pair.meta), { genesisHash: genesisHash }));
+        keyring.saveAccountMeta(pair, { ...pair.meta, genesisHash });
         return true;
-    };
-    Extension.prototype.accountsValidate = function (_a) {
-        var address = _a.address, password = _a.password;
+    }
+    accountsValidate({ address, password }) {
         try {
             keyring.backupAccount(keyring.getPair(address), password);
             return true;
         }
-        catch (_b) {
+        catch {
             return false;
         }
-    };
-    Extension.prototype.accountsSubscribe = function (id, port) {
-        var _this = this;
-        var cb = createSubscription(id, port);
-        var subscription = accountsObservable.subject.subscribe(function (accounts) {
-            return cb(_this.transformAccounts(accounts));
-        });
-        port.onDisconnect.addListener(function () {
+    }
+    accountsSubscribe(id, port) {
+        const cb = createSubscription(id, port);
+        const subscription = accountsObservable.subject.subscribe((accounts) => cb(this.transformAccounts(accounts)));
+        port.onDisconnect.addListener(() => {
             unsubscribe(id);
             subscription.unsubscribe();
         });
         return true;
-    };
-    Extension.prototype.authorizeApprove = function (_a) {
-        var authorizedAccounts = _a.authorizedAccounts, id = _a.id;
-        var queued = __classPrivateFieldGet(this, _Extension_state, "f").getAuthRequest(id);
+    }
+    authorizeApprove({ authorizedAccounts, id }) {
+        const queued = this.#state.getAuthRequest(id);
         assert(queued, 'Unable to find request');
-        var resolve = queued.resolve;
-        resolve({ authorizedAccounts: authorizedAccounts, result: true });
+        const { resolve } = queued;
+        resolve({ authorizedAccounts, result: true });
         return true;
-    };
-    Extension.prototype.authorizeUpdate = function (_a) {
-        return __awaiter(this, arguments, void 0, function (_b) {
-            var authorizedAccounts = _b.authorizedAccounts, url = _b.url;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0: return [4 /*yield*/, __classPrivateFieldGet(this, _Extension_state, "f").updateAuthorizedAccounts([[url, authorizedAccounts]])];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    Extension.prototype.getAuthList = function () {
-        return { list: __classPrivateFieldGet(this, _Extension_state, "f").authUrls };
-    };
+    }
+    async authorizeUpdate({ authorizedAccounts, url }) {
+        return await this.#state.updateAuthorizedAccounts([[url, authorizedAccounts]]);
+    }
+    getAuthList() {
+        return { list: this.#state.authUrls };
+    }
     // FIXME This looks very much like what we have in accounts
-    Extension.prototype.authorizeSubscribe = function (id, port) {
-        var cb = createSubscription(id, port);
-        var subscription = __classPrivateFieldGet(this, _Extension_state, "f").authSubject.subscribe(function (requests) {
-            return cb(requests);
-        });
-        port.onDisconnect.addListener(function () {
+    authorizeSubscribe(id, port) {
+        const cb = createSubscription(id, port);
+        const subscription = this.#state.authSubject.subscribe((requests) => cb(requests));
+        port.onDisconnect.addListener(() => {
             unsubscribe(id);
             subscription.unsubscribe();
         });
         return true;
-    };
-    Extension.prototype.metadataApprove = function (_a) {
-        return __awaiter(this, arguments, void 0, function (_b) {
-            var queued, request, resolve;
-            var id = _b.id;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        queued = __classPrivateFieldGet(this, _Extension_state, "f").getMetaRequest(id);
-                        assert(queued, 'Unable to find request');
-                        request = queued.request, resolve = queued.resolve;
-                        return [4 /*yield*/, __classPrivateFieldGet(this, _Extension_state, "f").saveMetadata(request)];
-                    case 1:
-                        _c.sent();
-                        resolve(true);
-                        return [2 /*return*/, true];
-                }
-            });
-        });
-    };
-    Extension.prototype.metadataGet = function (genesisHash) {
-        return __classPrivateFieldGet(this, _Extension_state, "f").knownMetadata.find(function (result) { return result.genesisHash === genesisHash; }) || null;
-    };
-    Extension.prototype.metadataList = function () {
-        return __classPrivateFieldGet(this, _Extension_state, "f").knownMetadata;
-    };
-    Extension.prototype.metadataReject = function (_a) {
-        var id = _a.id;
-        var queued = __classPrivateFieldGet(this, _Extension_state, "f").getMetaRequest(id);
+    }
+    async metadataApprove({ id }) {
+        const queued = this.#state.getMetaRequest(id);
         assert(queued, 'Unable to find request');
-        var reject = queued.reject;
+        const { request, resolve } = queued;
+        await this.#state.saveMetadata(request);
+        resolve(true);
+        return true;
+    }
+    metadataGet(genesisHash) {
+        return this.#state.knownMetadata.find((result) => result.genesisHash === genesisHash) || null;
+    }
+    metadataList() {
+        return this.#state.knownMetadata;
+    }
+    metadataReject({ id }) {
+        const queued = this.#state.getMetaRequest(id);
+        assert(queued, 'Unable to find request');
+        const { reject } = queued;
         reject(new Error('Rejected'));
         return true;
-    };
-    Extension.prototype.metadataSubscribe = function (id, port) {
-        var cb = createSubscription(id, port);
-        var subscription = __classPrivateFieldGet(this, _Extension_state, "f").metaSubject.subscribe(function (requests) {
-            return cb(requests);
-        });
-        port.onDisconnect.addListener(function () {
+    }
+    metadataSubscribe(id, port) {
+        const cb = createSubscription(id, port);
+        const subscription = this.#state.metaSubject.subscribe((requests) => cb(requests));
+        port.onDisconnect.addListener(() => {
             unsubscribe(id);
             subscription.unsubscribe();
         });
         return true;
-    };
-    Extension.prototype.jsonRestore = function (_a) {
-        var file = _a.file, password = _a.password;
+    }
+    jsonRestore({ file, password }) {
         try {
             keyring.restoreAccount(file, password);
         }
         catch (error) {
             throw new Error(error.message);
         }
-    };
-    Extension.prototype.batchRestore = function (_a) {
-        var file = _a.file, password = _a.password;
+    }
+    batchRestore({ file, password }) {
         try {
             keyring.restoreAccounts(file, password);
         }
         catch (error) {
             throw new Error(error.message);
         }
-    };
-    Extension.prototype.jsonGetAccountInfo = function (json) {
+    }
+    jsonGetAccountInfo(json) {
         try {
-            var _a = keyring.createFromJson(json), address = _a.address, _b = _a.meta, genesisHash = _b.genesisHash, name_1 = _b.name, type = _a.type;
+            const { address, meta: { genesisHash, name }, type } = keyring.createFromJson(json);
             return {
-                address: address,
-                genesisHash: genesisHash,
-                name: name_1,
-                type: type
+                address,
+                genesisHash,
+                name,
+                type
             };
         }
         catch (e) {
             console.error(e);
             throw new Error(e.message);
         }
-    };
-    Extension.prototype.seedCreate = function (_a) {
-        var _b = _a.length, length = _b === void 0 ? SEED_DEFAULT_LENGTH : _b, _seed = _a.seed, type = _a.type;
-        var seed = _seed || mnemonicGenerate(length);
+    }
+    seedCreate({ length = SEED_DEFAULT_LENGTH, seed: _seed, type }) {
+        const seed = _seed || mnemonicGenerate(length);
         return {
             address: keyring.createFromUri(getSuri(seed, type), {}, type).address,
-            seed: seed
+            seed
         };
-    };
-    Extension.prototype.seedValidate = function (_a) {
-        var suri = _a.suri, type = _a.type;
-        var phrase = keyExtractSuri(suri).phrase;
+    }
+    seedValidate({ suri, type }) {
+        const { phrase } = keyExtractSuri(suri);
         if (isHex(phrase)) {
             assert(isHex(phrase, 256), 'Hex seed needs to be 256-bits');
         }
         else {
             // sadly isHex detects as string, so we need a cast here
-            assert(SEED_LENGTHS.includes((phrase).split(' ').length), "Mnemonic needs to contain ".concat(SEED_LENGTHS.join(', '), " words"));
+            assert(SEED_LENGTHS.includes((phrase).split(' ').length), `Mnemonic needs to contain ${SEED_LENGTHS.join(', ')} words`);
             assert(mnemonicValidate(phrase), 'Not a valid mnemonic seed');
         }
         return {
             address: keyring.createFromUri(getSuri(suri, type), {}, type).address,
-            suri: suri
+            suri
         };
-    };
-    Extension.prototype.signingApprovePassword = function (_a) {
-        var id = _a.id, password = _a.password, savePass = _a.savePass;
-        var queued = __classPrivateFieldGet(this, _Extension_state, "f").getSignRequest(id);
+    }
+    signingApprovePassword({ id, password, savePass }) {
+        const queued = this.#state.getSignRequest(id);
         assert(queued, 'Unable to find request');
-        var reject = queued.reject, request = queued.request, resolve = queued.resolve;
-        var pair = keyring.getPair(queued.account.address);
+        const { reject, request, resolve } = queued;
+        const pair = keyring.getPair(queued.account.address);
         if (!pair) {
             reject(new Error('Unable to find pair'));
             return false;
@@ -382,17 +256,14 @@ var Extension = /** @class */ (function () {
             pair.decodePkcs8(password);
         }
         // construct a new registry (avoiding pollution), between requests
-        var registry;
-        var payload = request.payload;
+        let registry;
+        const { payload } = request;
         if (isJsonPayload(payload)) {
             // Get the metadata for the genesisHash
-            var metadata = __classPrivateFieldGet(this, _Extension_state, "f").knownMetadata.find(function (_a) {
-                var genesisHash = _a.genesisHash;
-                return genesisHash === payload.genesisHash;
-            });
+            const metadata = this.#state.knownMetadata.find(({ genesisHash }) => genesisHash === payload.genesisHash);
             if (metadata) {
                 // we have metadata, expand it and extract the info/registry
-                var expanded = metadataExpand(metadata, false);
+                const expanded = metadataExpand(metadata, false);
                 registry = expanded.registry;
                 registry.setSignedExtensions(payload.signedExtensions, expanded.definition.userExtensions);
             }
@@ -406,240 +277,213 @@ var Extension = /** @class */ (function () {
             // for non-payload, just create a registry to use
             registry = new TypeRegistry();
         }
-        var result = request.sign(registry, pair);
+        const result = request.sign(registry, pair);
         if (savePass) {
             // unlike queued.account.address the following
             // address is encoded with the default prefix
             // which what is used for password caching mapping
-            __classPrivateFieldGet(this, _Extension_cachedUnlocks, "f")[pair.address] = Date.now() + PASSWORD_EXPIRY_MS;
+            this.#cachedUnlocks[pair.address] = Date.now() + PASSWORD_EXPIRY_MS;
         }
         else {
             pair.lock();
         }
-        resolve(__assign({ id: id }, result));
+        resolve({
+            id,
+            ...result
+        });
         return true;
-    };
-    Extension.prototype.signingApproveSignature = function (_a) {
-        var id = _a.id, signature = _a.signature, signedTransaction = _a.signedTransaction;
-        var queued = __classPrivateFieldGet(this, _Extension_state, "f").getSignRequest(id);
+    }
+    signingApproveSignature({ id, signature, signedTransaction }) {
+        const queued = this.#state.getSignRequest(id);
         assert(queued, 'Unable to find request');
-        var resolve = queued.resolve;
-        resolve({ id: id, signature: signature, signedTransaction: signedTransaction });
+        const { resolve } = queued;
+        resolve({ id, signature, signedTransaction });
         return true;
-    };
-    Extension.prototype.signingCancel = function (_a) {
-        var id = _a.id;
-        var queued = __classPrivateFieldGet(this, _Extension_state, "f").getSignRequest(id);
+    }
+    signingCancel({ id }) {
+        const queued = this.#state.getSignRequest(id);
         assert(queued, 'Unable to find request');
-        var reject = queued.reject;
+        const { reject } = queued;
         reject(new Error('Cancelled'));
         return true;
-    };
-    Extension.prototype.signingIsLocked = function (_a) {
-        var id = _a.id;
-        var queued = __classPrivateFieldGet(this, _Extension_state, "f").getSignRequest(id);
+    }
+    signingIsLocked({ id }) {
+        const queued = this.#state.getSignRequest(id);
         assert(queued, 'Unable to find request');
-        var address = queued.request.payload.address;
-        var pair = keyring.getPair(address);
+        const address = queued.request.payload.address;
+        const pair = keyring.getPair(address);
         assert(pair, 'Unable to find pair');
-        var remainingTime = this.refreshAccountPasswordCache(pair);
+        const remainingTime = this.refreshAccountPasswordCache(pair);
         return {
             isLocked: pair.isLocked,
-            remainingTime: remainingTime
+            remainingTime
         };
-    };
+    }
     // FIXME This looks very much like what we have in authorization
-    Extension.prototype.signingSubscribe = function (id, port) {
-        var cb = createSubscription(id, port);
-        var subscription = __classPrivateFieldGet(this, _Extension_state, "f").signSubject.subscribe(function (requests) {
-            return cb(requests);
-        });
-        port.onDisconnect.addListener(function () {
+    signingSubscribe(id, port) {
+        const cb = createSubscription(id, port);
+        const subscription = this.#state.signSubject.subscribe((requests) => cb(requests));
+        port.onDisconnect.addListener(() => {
             unsubscribe(id);
             subscription.unsubscribe();
         });
         return true;
-    };
-    Extension.prototype.windowOpen = function (path) {
-        var url = "".concat(chrome.runtime.getURL('index.html'), "#").concat(path);
+    }
+    windowOpen(path) {
+        const url = `${chrome.runtime.getURL('index.html')}#${path}`;
         if (!ALLOWED_PATH.includes(path)) {
             console.error('Not allowed to open the url:', url);
             return false;
         }
-        withErrorLog(function () { return chrome.tabs.create({ url: url }); });
+        withErrorLog(() => chrome.tabs.create({ url }));
         return true;
-    };
-    Extension.prototype.derive = function (parentAddress, suri, password, metadata) {
-        var parentPair = keyring.getPair(parentAddress);
+    }
+    derive(parentAddress, suri, password, metadata) {
+        const parentPair = keyring.getPair(parentAddress);
         try {
             parentPair.decodePkcs8(password);
         }
-        catch (_a) {
+        catch {
             throw new Error('invalid password');
         }
         try {
             return parentPair.derive(suri, metadata);
         }
-        catch (_b) {
-            throw new Error("\"".concat(suri, "\" is not a valid derivation path"));
+        catch {
+            throw new Error(`"${suri}" is not a valid derivation path`);
         }
-    };
-    Extension.prototype.derivationValidate = function (_a) {
-        var parentAddress = _a.parentAddress, parentPassword = _a.parentPassword, suri = _a.suri;
-        var childPair = this.derive(parentAddress, suri, parentPassword, {});
+    }
+    derivationValidate({ parentAddress, parentPassword, suri }) {
+        const childPair = this.derive(parentAddress, suri, parentPassword, {});
         return {
             address: childPair.address,
-            suri: suri
+            suri
         };
-    };
-    Extension.prototype.derivationCreate = function (_a) {
-        var genesisHash = _a.genesisHash, name = _a.name, parentAddress = _a.parentAddress, parentPassword = _a.parentPassword, password = _a.password, suri = _a.suri;
-        var childPair = this.derive(parentAddress, suri, parentPassword, {
-            genesisHash: genesisHash,
-            name: name,
-            parentAddress: parentAddress,
-            suri: suri
+    }
+    derivationCreate({ genesisHash, name, parentAddress, parentPassword, password, suri }) {
+        const childPair = this.derive(parentAddress, suri, parentPassword, {
+            genesisHash,
+            name,
+            parentAddress,
+            suri
         });
         keyring.addPair(childPair, password);
         return true;
-    };
-    Extension.prototype.removeAuthorization = function (url) {
-        return __awaiter(this, void 0, void 0, function () {
-            var remAuth;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, __classPrivateFieldGet(this, _Extension_state, "f").removeAuthorization(url)];
-                    case 1:
-                        remAuth = _a.sent();
-                        return [2 /*return*/, { list: remAuth }];
-                }
-            });
-        });
-    };
+    }
+    async removeAuthorization(url) {
+        const remAuth = await this.#state.removeAuthorization(url);
+        return { list: remAuth };
+    }
     // Reject the authorization request and add the URL to the authorized list with no keys.
     // The site will not prompt for re-authorization on future visits.
-    Extension.prototype.rejectAuthRequest = function (id) {
-        var queued = __classPrivateFieldGet(this, _Extension_state, "f").getAuthRequest(id);
+    rejectAuthRequest(id) {
+        const queued = this.#state.getAuthRequest(id);
         assert(queued, 'Unable to find request');
-        var reject = queued.reject;
+        const { reject } = queued;
         reject(new Error('Rejected'));
-    };
+    }
     // Cancel the authorization request and do not add the URL to the authorized list.
     // The site will prompt for authorization on future visits.
-    Extension.prototype.cancelAuthRequest = function (id) {
-        var queued = __classPrivateFieldGet(this, _Extension_state, "f").getAuthRequest(id);
+    cancelAuthRequest(id) {
+        const queued = this.#state.getAuthRequest(id);
         assert(queued, 'Unable to find request');
-        var reject = queued.reject;
+        const { reject } = queued;
         reject(new Error('Cancelled'));
-    };
-    Extension.prototype.updateCurrentTabs = function (_a) {
-        var urls = _a.urls;
-        __classPrivateFieldGet(this, _Extension_state, "f").updateCurrentTabsUrl(urls);
-    };
-    Extension.prototype.getConnectedTabsUrl = function () {
-        return __classPrivateFieldGet(this, _Extension_state, "f").getConnectedTabsUrl();
-    };
+    }
+    updateCurrentTabs({ urls }) {
+        this.#state.updateCurrentTabsUrl(urls);
+    }
+    getConnectedTabsUrl() {
+        return this.#state.getConnectedTabsUrl();
+    }
     // Weird thought, the eslint override is not needed in Tabs
     // eslint-disable-next-line @typescript-eslint/require-await
-    Extension.prototype.handle = function (id, type, request, port) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = type;
-                        switch (_a) {
-                            case 'pri(authorize.approve)': return [3 /*break*/, 1];
-                            case 'pri(authorize.list)': return [3 /*break*/, 2];
-                            case 'pri(authorize.remove)': return [3 /*break*/, 3];
-                            case 'pri(authorize.reject)': return [3 /*break*/, 4];
-                            case 'pri(authorize.cancel)': return [3 /*break*/, 5];
-                            case 'pri(authorize.requests)': return [3 /*break*/, 6];
-                            case 'pri(authorize.update)': return [3 /*break*/, 7];
-                            case 'pri(accounts.create.external)': return [3 /*break*/, 8];
-                            case 'pri(accounts.create.hardware)': return [3 /*break*/, 9];
-                            case 'pri(accounts.create.suri)': return [3 /*break*/, 10];
-                            case 'pri(accounts.changePassword)': return [3 /*break*/, 11];
-                            case 'pri(accounts.edit)': return [3 /*break*/, 12];
-                            case 'pri(accounts.export)': return [3 /*break*/, 13];
-                            case 'pri(accounts.batchExport)': return [3 /*break*/, 14];
-                            case 'pri(accounts.forget)': return [3 /*break*/, 15];
-                            case 'pri(accounts.show)': return [3 /*break*/, 16];
-                            case 'pri(accounts.subscribe)': return [3 /*break*/, 17];
-                            case 'pri(accounts.tie)': return [3 /*break*/, 18];
-                            case 'pri(accounts.validate)': return [3 /*break*/, 19];
-                            case 'pri(metadata.approve)': return [3 /*break*/, 20];
-                            case 'pri(metadata.get)': return [3 /*break*/, 22];
-                            case 'pri(metadata.list)': return [3 /*break*/, 23];
-                            case 'pri(metadata.reject)': return [3 /*break*/, 24];
-                            case 'pri(metadata.requests)': return [3 /*break*/, 25];
-                            case 'pri(activeTabsUrl.update)': return [3 /*break*/, 26];
-                            case 'pri(connectedTabsUrl.get)': return [3 /*break*/, 27];
-                            case 'pri(derivation.create)': return [3 /*break*/, 28];
-                            case 'pri(derivation.validate)': return [3 /*break*/, 29];
-                            case 'pri(json.restore)': return [3 /*break*/, 30];
-                            case 'pri(json.batchRestore)': return [3 /*break*/, 31];
-                            case 'pri(json.account.info)': return [3 /*break*/, 32];
-                            case 'pri(ping)': return [3 /*break*/, 33];
-                            case 'pri(seed.create)': return [3 /*break*/, 34];
-                            case 'pri(seed.validate)': return [3 /*break*/, 35];
-                            case 'pri(settings.notification)': return [3 /*break*/, 36];
-                            case 'pri(signing.approve.password)': return [3 /*break*/, 37];
-                            case 'pri(signing.approve.signature)': return [3 /*break*/, 38];
-                            case 'pri(signing.cancel)': return [3 /*break*/, 39];
-                            case 'pri(signing.isLocked)': return [3 /*break*/, 40];
-                            case 'pri(signing.requests)': return [3 /*break*/, 41];
-                            case 'pri(window.open)': return [3 /*break*/, 42];
-                        }
-                        return [3 /*break*/, 43];
-                    case 1: return [2 /*return*/, this.authorizeApprove(request)];
-                    case 2: return [2 /*return*/, this.getAuthList()];
-                    case 3: return [2 /*return*/, this.removeAuthorization(request)];
-                    case 4: return [2 /*return*/, this.rejectAuthRequest(request)];
-                    case 5: return [2 /*return*/, this.cancelAuthRequest(request)];
-                    case 6: return [2 /*return*/, port && this.authorizeSubscribe(id, port)];
-                    case 7: return [2 /*return*/, this.authorizeUpdate(request)];
-                    case 8: return [2 /*return*/, this.accountsCreateExternal(request)];
-                    case 9: return [2 /*return*/, this.accountsCreateHardware(request)];
-                    case 10: return [2 /*return*/, this.accountsCreateSuri(request)];
-                    case 11: return [2 /*return*/, this.accountsChangePassword(request)];
-                    case 12: return [2 /*return*/, this.accountsEdit(request)];
-                    case 13: return [2 /*return*/, this.accountsExport(request)];
-                    case 14: return [2 /*return*/, this.accountsBatchExport(request)];
-                    case 15: return [2 /*return*/, this.accountsForget(request)];
-                    case 16: return [2 /*return*/, this.accountsShow(request)];
-                    case 17: return [2 /*return*/, port && this.accountsSubscribe(id, port)];
-                    case 18: return [2 /*return*/, this.accountsTie(request)];
-                    case 19: return [2 /*return*/, this.accountsValidate(request)];
-                    case 20: return [4 /*yield*/, this.metadataApprove(request)];
-                    case 21: return [2 /*return*/, _b.sent()];
-                    case 22: return [2 /*return*/, this.metadataGet(request)];
-                    case 23: return [2 /*return*/, this.metadataList()];
-                    case 24: return [2 /*return*/, this.metadataReject(request)];
-                    case 25: return [2 /*return*/, port && this.metadataSubscribe(id, port)];
-                    case 26: return [2 /*return*/, this.updateCurrentTabs(request)];
-                    case 27: return [2 /*return*/, this.getConnectedTabsUrl()];
-                    case 28: return [2 /*return*/, this.derivationCreate(request)];
-                    case 29: return [2 /*return*/, this.derivationValidate(request)];
-                    case 30: return [2 /*return*/, this.jsonRestore(request)];
-                    case 31: return [2 /*return*/, this.batchRestore(request)];
-                    case 32: return [2 /*return*/, this.jsonGetAccountInfo(request)];
-                    case 33: return [2 /*return*/, Promise.resolve(true)];
-                    case 34: return [2 /*return*/, this.seedCreate(request)];
-                    case 35: return [2 /*return*/, this.seedValidate(request)];
-                    case 36: return [2 /*return*/, __classPrivateFieldGet(this, _Extension_state, "f").setNotification(request)];
-                    case 37: return [2 /*return*/, this.signingApprovePassword(request)];
-                    case 38: return [2 /*return*/, this.signingApproveSignature(request)];
-                    case 39: return [2 /*return*/, this.signingCancel(request)];
-                    case 40: return [2 /*return*/, this.signingIsLocked(request)];
-                    case 41: return [2 /*return*/, port && this.signingSubscribe(id, port)];
-                    case 42: return [2 /*return*/, this.windowOpen(request)];
-                    case 43: throw new Error("Unable to handle message of type ".concat(type));
-                }
-            });
-        });
-    };
-    return Extension;
-}());
-_Extension_cachedUnlocks = new WeakMap(), _Extension_state = new WeakMap();
-export default Extension;
+    async handle(id, type, request, port) {
+        switch (type) {
+            case 'pri(authorize.approve)':
+                return this.authorizeApprove(request);
+            case 'pri(authorize.list)':
+                return this.getAuthList();
+            case 'pri(authorize.remove)':
+                return this.removeAuthorization(request);
+            case 'pri(authorize.reject)':
+                return this.rejectAuthRequest(request);
+            case 'pri(authorize.cancel)':
+                return this.cancelAuthRequest(request);
+            case 'pri(authorize.requests)':
+                return port && this.authorizeSubscribe(id, port);
+            case 'pri(authorize.update)':
+                return this.authorizeUpdate(request);
+            case 'pri(accounts.create.external)':
+                return this.accountsCreateExternal(request);
+            case 'pri(accounts.create.hardware)':
+                return this.accountsCreateHardware(request);
+            case 'pri(accounts.create.suri)':
+                return this.accountsCreateSuri(request);
+            case 'pri(accounts.changePassword)':
+                return this.accountsChangePassword(request);
+            case 'pri(accounts.edit)':
+                return this.accountsEdit(request);
+            case 'pri(accounts.export)':
+                return this.accountsExport(request);
+            case 'pri(accounts.batchExport)':
+                return this.accountsBatchExport(request);
+            case 'pri(accounts.forget)':
+                return this.accountsForget(request);
+            case 'pri(accounts.show)':
+                return this.accountsShow(request);
+            case 'pri(accounts.subscribe)':
+                return port && this.accountsSubscribe(id, port);
+            case 'pri(accounts.tie)':
+                return this.accountsTie(request);
+            case 'pri(accounts.validate)':
+                return this.accountsValidate(request);
+            case 'pri(metadata.approve)':
+                return await this.metadataApprove(request);
+            case 'pri(metadata.get)':
+                return this.metadataGet(request);
+            case 'pri(metadata.list)':
+                return this.metadataList();
+            case 'pri(metadata.reject)':
+                return this.metadataReject(request);
+            case 'pri(metadata.requests)':
+                return port && this.metadataSubscribe(id, port);
+            case 'pri(activeTabsUrl.update)':
+                return this.updateCurrentTabs(request);
+            case 'pri(connectedTabsUrl.get)':
+                return this.getConnectedTabsUrl();
+            case 'pri(derivation.create)':
+                return this.derivationCreate(request);
+            case 'pri(derivation.validate)':
+                return this.derivationValidate(request);
+            case 'pri(json.restore)':
+                return this.jsonRestore(request);
+            case 'pri(json.batchRestore)':
+                return this.batchRestore(request);
+            case 'pri(json.account.info)':
+                return this.jsonGetAccountInfo(request);
+            case 'pri(ping)':
+                return Promise.resolve(true);
+            case 'pri(seed.create)':
+                return this.seedCreate(request);
+            case 'pri(seed.validate)':
+                return this.seedValidate(request);
+            case 'pri(settings.notification)':
+                return this.#state.setNotification(request);
+            case 'pri(signing.approve.password)':
+                return this.signingApprovePassword(request);
+            case 'pri(signing.approve.signature)':
+                return this.signingApproveSignature(request);
+            case 'pri(signing.cancel)':
+                return this.signingCancel(request);
+            case 'pri(signing.isLocked)':
+                return this.signingIsLocked(request);
+            case 'pri(signing.requests)':
+                return port && this.signingSubscribe(id, port);
+            case 'pri(window.open)':
+                return this.windowOpen(request);
+            default:
+                throw new Error(`Unable to handle message of type ${type}`);
+        }
+    }
+}