@pezkuwi/extension-base 0.62.8 → 0.62.12

package/background/handlers/index.js

@@ -0,0 +1,40 @@
+import { assert } from '@pezkuwi/util';
+import { PORT_EXTENSION } from '../../defaults.js';
+import Extension from './Extension.js';
+import State from './State.js';
+import Tabs from './Tabs.js';
+export { withErrorLog } from './helpers.js';
+const state = new State();
+await state.init();
+const extension = new Extension(state);
+const tabs = new Tabs(state);
+export default function handler({ id, message, request }, port, extensionPortName = PORT_EXTENSION) {
+    const isExtension = !port || port?.name === extensionPortName;
+    const sender = port?.sender;
+    if (!isExtension && !sender) {
+        throw new Error('Unable to extract message sender');
+    }
+    const from = isExtension
+        ? 'extension'
+        : sender?.url || sender?.tab?.url || '<unknown>';
+    const source = `${from}: ${id}: ${message}`;
+    console.log(` [in] ${source}`); // :: ${JSON.stringify(request)}`);
+    const promise = isExtension
+        ? extension.handle(id, message, request, port)
+        : tabs.handle(id, message, request, from, port);
+    promise
+        .then((response) => {
+        console.log(`[out] ${source}`); // :: ${JSON.stringify(response)}`);
+        // between the start and the end of the promise, the user may have closed
+        // the tab, in which case port will be undefined
+        assert(port, 'Port has been disconnected');
+        port.postMessage({ id, response });
+    })
+        .catch((error) => {
+        console.log(`[err] ${source}:: ${error.message}`);
+        // only send message back to port if it's still connected
+        if (port) {
+            port.postMessage({ error: error.message, id });
+        }
+    });
+}

package/background/handlers/subscriptions.js

@@ -0,0 +1,18 @@
+const subscriptions = {};
+export function createSubscription(id, port) {
+    subscriptions[id] = port;
+    return (subscription) => {
+        if (subscriptions[id]) {
+            port.postMessage({ id, subscription });
+        }
+    };
+}
+export function unsubscribe(id) {
+    if (subscriptions[id]) {
+        console.log(`Unsubscribing from ${id}`);
+        delete subscriptions[id];
+    }
+    else {
+        console.error(`Unable to unsubscribe from ${id}`);
+    }
+}

package/background/index.js

@@ -0,0 +1 @@
+export { default as handlers, withErrorLog } from './handlers/index.js';

package/bundle.js

@@ -0,0 +1 @@
+export { packageInfo } from './packageInfo.js';

package/cjs/background/RequestBytesSign.d.ts

@@ -0,0 +1,12 @@
+import type { KeyringPair } from '@pezkuwi/keyring/types';
+import type { TypeRegistry } from '@pezkuwi/types';
+import type { SignerPayloadRaw } from '@pezkuwi/types/types';
+import type { HexString } from '@pezkuwi/util/types';
+import type { RequestSign } from './types.js';
+export default class RequestBytesSign implements RequestSign {
+    readonly payload: SignerPayloadRaw;
+    constructor(payload: SignerPayloadRaw);
+    sign(_registry: TypeRegistry, pair: KeyringPair): {
+        signature: HexString;
+    };
+}

package/cjs/background/RequestBytesSign.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("@pezkuwi/util");
+class RequestBytesSign {
+    payload;
+    constructor(payload) {
+        this.payload = payload;
+    }
+    sign(_registry, pair) {
+        return {
+            signature: (0, util_1.u8aToHex)(pair.sign((0, util_1.u8aWrapBytes)(this.payload.data)))
+        };
+    }
+}
+exports.default = RequestBytesSign;

package/cjs/background/RequestExtrinsicSign.d.ts

@@ -0,0 +1,12 @@
+import type { KeyringPair } from '@pezkuwi/keyring/types';
+import type { TypeRegistry } from '@pezkuwi/types';
+import type { SignerPayloadJSON } from '@pezkuwi/types/types';
+import type { HexString } from '@pezkuwi/util/types';
+import type { RequestSign } from './types.js';
+export default class RequestExtrinsicSign implements RequestSign {
+    readonly payload: SignerPayloadJSON;
+    constructor(payload: SignerPayloadJSON);
+    sign(registry: TypeRegistry, pair: KeyringPair): {
+        signature: HexString;
+    };
+}

package/cjs/background/RequestExtrinsicSign.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class RequestExtrinsicSign {
+    payload;
+    constructor(payload) {
+        this.payload = payload;
+    }
+    sign(registry, pair) {
+        return registry
+            .createType('ExtrinsicPayload', this.payload, { version: this.payload.version })
+            .sign(pair);
+    }
+}
+exports.default = RequestExtrinsicSign;

package/cjs/background/handlers/Extension.d.ts

@@ -0,0 +1,49 @@
+import type { MessageTypes, RequestTypes, ResponseType } from '../types.js';
+import type State from './State.js';
+export default class Extension {
+    #private;
+    constructor(state: State);
+    private transformAccounts;
+    private accountsCreateExternal;
+    private accountsCreateHardware;
+    private accountsCreateSuri;
+    private accountsChangePassword;
+    private accountsEdit;
+    private accountsExport;
+    private accountsBatchExport;
+    private accountsForget;
+    private refreshAccountPasswordCache;
+    private accountsShow;
+    private accountsTie;
+    private accountsValidate;
+    private accountsSubscribe;
+    private authorizeApprove;
+    private authorizeUpdate;
+    private getAuthList;
+    private authorizeSubscribe;
+    private metadataApprove;
+    private metadataGet;
+    private metadataList;
+    private metadataReject;
+    private metadataSubscribe;
+    private jsonRestore;
+    private batchRestore;
+    private jsonGetAccountInfo;
+    private seedCreate;
+    private seedValidate;
+    private signingApprovePassword;
+    private signingApproveSignature;
+    private signingCancel;
+    private signingIsLocked;
+    private signingSubscribe;
+    private windowOpen;
+    private derive;
+    private derivationValidate;
+    private derivationCreate;
+    private removeAuthorization;
+    private rejectAuthRequest;
+    private cancelAuthRequest;
+    private updateCurrentTabs;
+    private getConnectedTabsUrl;
+    handle<TMessageType extends MessageTypes>(id: string, type: TMessageType, request: RequestTypes[TMessageType], port?: chrome.runtime.Port): Promise<ResponseType<TMessageType>>;
+}

package/cjs/background/handlers/Extension.js

@@ -0,0 +1,492 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const defaults_1 = require("@pezkuwi/extension-base/defaults");
+const extension_chains_1 = require("@pezkuwi/extension-chains");
+const types_1 = require("@pezkuwi/types");
+const ui_keyring_1 = require("@pezkuwi/ui-keyring");
+const accounts_1 = require("@pezkuwi/ui-keyring/observable/accounts");
+const util_1 = require("@pezkuwi/util");
+const util_crypto_1 = require("@pezkuwi/util-crypto");
+const helpers_js_1 = require("./helpers.js");
+const subscriptions_js_1 = require("./subscriptions.js");
+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'
+        ? `${seed}${ETH_DERIVE_DEFAULT}`
+        : seed;
+}
+function isJsonPayload(value) {
+    return value.genesisHash !== undefined;
+}
+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 }) {
+        ui_keyring_1.keyring.addExternal(address, { genesisHash, name });
+        return true;
+    }
+    accountsCreateHardware({ accountIndex, address, addressOffset, genesisHash, hardwareType, name, type }) {
+        ui_keyring_1.keyring.addHardware(address, hardwareType, { accountIndex, addressOffset, genesisHash, name, type });
+        return true;
+    }
+    accountsCreateSuri({ genesisHash, name, password, suri, type }) {
+        ui_keyring_1.keyring.addUri(getSuri(suri, type), password, { genesisHash, name }, type);
+        return true;
+    }
+    accountsChangePassword({ address, newPass, oldPass }) {
+        const pair = ui_keyring_1.keyring.getPair(address);
+        (0, util_1.assert)(pair, 'Unable to find pair');
+        try {
+            if (!pair.isLocked) {
+                pair.lock();
+            }
+            pair.decodePkcs8(oldPass);
+        }
+        catch {
+            throw new Error('oldPass is invalid');
+        }
+        ui_keyring_1.keyring.encryptAccount(pair, newPass);
+        return true;
+    }
+    accountsEdit({ address, name }) {
+        const pair = ui_keyring_1.keyring.getPair(address);
+        (0, util_1.assert)(pair, 'Unable to find pair');
+        ui_keyring_1.keyring.saveAccountMeta(pair, { ...pair.meta, name });
+        return true;
+    }
+    accountsExport({ address, password }) {
+        return { exportedJson: ui_keyring_1.keyring.backupAccount(ui_keyring_1.keyring.getPair(address), password) };
+    }
+    async accountsBatchExport({ addresses, password }) {
+        return {
+            exportedJson: await ui_keyring_1.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)]);
+            }
+        });
+        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);
+        ui_keyring_1.keyring.forgetAccount(address);
+        return true;
+    }
+    refreshAccountPasswordCache(pair) {
+        const { address } = pair;
+        const savedExpiry = this.#cachedUnlocks[address] || 0;
+        const remainingTime = savedExpiry - Date.now();
+        if (remainingTime < 0) {
+            this.#cachedUnlocks[address] = 0;
+            pair.lock();
+            return 0;
+        }
+        return remainingTime;
+    }
+    accountsShow({ address, isShowing }) {
+        const pair = ui_keyring_1.keyring.getPair(address);
+        (0, util_1.assert)(pair, 'Unable to find pair');
+        ui_keyring_1.keyring.saveAccountMeta(pair, { ...pair.meta, isHidden: !isShowing });
+        return true;
+    }
+    accountsTie({ address, genesisHash }) {
+        const pair = ui_keyring_1.keyring.getPair(address);
+        (0, util_1.assert)(pair, 'Unable to find pair');
+        ui_keyring_1.keyring.saveAccountMeta(pair, { ...pair.meta, genesisHash });
+        return true;
+    }
+    accountsValidate({ address, password }) {
+        try {
+            ui_keyring_1.keyring.backupAccount(ui_keyring_1.keyring.getPair(address), password);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    accountsSubscribe(id, port) {
+        const cb = (0, subscriptions_js_1.createSubscription)(id, port);
+        const subscription = accounts_1.accounts.subject.subscribe((accounts) => cb(this.transformAccounts(accounts)));
+        port.onDisconnect.addListener(() => {
+            (0, subscriptions_js_1.unsubscribe)(id);
+            subscription.unsubscribe();
+        });
+        return true;
+    }
+    authorizeApprove({ authorizedAccounts, id }) {
+        const queued = this.#state.getAuthRequest(id);
+        (0, util_1.assert)(queued, 'Unable to find request');
+        const { resolve } = queued;
+        resolve({ authorizedAccounts, result: true });
+        return true;
+    }
+    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
+    authorizeSubscribe(id, port) {
+        const cb = (0, subscriptions_js_1.createSubscription)(id, port);
+        const subscription = this.#state.authSubject.subscribe((requests) => cb(requests));
+        port.onDisconnect.addListener(() => {
+            (0, subscriptions_js_1.unsubscribe)(id);
+            subscription.unsubscribe();
+        });
+        return true;
+    }
+    async metadataApprove({ id }) {
+        const queued = this.#state.getMetaRequest(id);
+        (0, util_1.assert)(queued, 'Unable to find request');
+        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);
+        (0, util_1.assert)(queued, 'Unable to find request');
+        const { reject } = queued;
+        reject(new Error('Rejected'));
+        return true;
+    }
+    metadataSubscribe(id, port) {
+        const cb = (0, subscriptions_js_1.createSubscription)(id, port);
+        const subscription = this.#state.metaSubject.subscribe((requests) => cb(requests));
+        port.onDisconnect.addListener(() => {
+            (0, subscriptions_js_1.unsubscribe)(id);
+            subscription.unsubscribe();
+        });
+        return true;
+    }
+    jsonRestore({ file, password }) {
+        try {
+            ui_keyring_1.keyring.restoreAccount(file, password);
+        }
+        catch (error) {
+            throw new Error(error.message);
+        }
+    }
+    batchRestore({ file, password }) {
+        try {
+            ui_keyring_1.keyring.restoreAccounts(file, password);
+        }
+        catch (error) {
+            throw new Error(error.message);
+        }
+    }
+    jsonGetAccountInfo(json) {
+        try {
+            const { address, meta: { genesisHash, name }, type } = ui_keyring_1.keyring.createFromJson(json);
+            return {
+                address,
+                genesisHash,
+                name,
+                type
+            };
+        }
+        catch (e) {
+            console.error(e);
+            throw new Error(e.message);
+        }
+    }
+    seedCreate({ length = SEED_DEFAULT_LENGTH, seed: _seed, type }) {
+        const seed = _seed || (0, util_crypto_1.mnemonicGenerate)(length);
+        return {
+            address: ui_keyring_1.keyring.createFromUri(getSuri(seed, type), {}, type).address,
+            seed
+        };
+    }
+    seedValidate({ suri, type }) {
+        const { phrase } = (0, util_crypto_1.keyExtractSuri)(suri);
+        if ((0, util_1.isHex)(phrase)) {
+            (0, util_1.assert)((0, util_1.isHex)(phrase, 256), 'Hex seed needs to be 256-bits');
+        }
+        else {
+            // sadly isHex detects as string, so we need a cast here
+            (0, util_1.assert)(SEED_LENGTHS.includes((phrase).split(' ').length), `Mnemonic needs to contain ${SEED_LENGTHS.join(', ')} words`);
+            (0, util_1.assert)((0, util_crypto_1.mnemonicValidate)(phrase), 'Not a valid mnemonic seed');
+        }
+        return {
+            address: ui_keyring_1.keyring.createFromUri(getSuri(suri, type), {}, type).address,
+            suri
+        };
+    }
+    signingApprovePassword({ id, password, savePass }) {
+        const queued = this.#state.getSignRequest(id);
+        (0, util_1.assert)(queued, 'Unable to find request');
+        const { reject, request, resolve } = queued;
+        const pair = ui_keyring_1.keyring.getPair(queued.account.address);
+        if (!pair) {
+            reject(new Error('Unable to find pair'));
+            return false;
+        }
+        this.refreshAccountPasswordCache(pair);
+        // if the keyring pair is locked, the password is needed
+        if (pair.isLocked && !password) {
+            reject(new Error('Password needed to unlock the account'));
+        }
+        if (pair.isLocked) {
+            pair.decodePkcs8(password);
+        }
+        // construct a new registry (avoiding pollution), between requests
+        let registry;
+        const { payload } = request;
+        if (isJsonPayload(payload)) {
+            // Get the metadata for the genesisHash
+            const metadata = this.#state.knownMetadata.find(({ genesisHash }) => genesisHash === payload.genesisHash);
+            if (metadata) {
+                // we have metadata, expand it and extract the info/registry
+                const expanded = (0, extension_chains_1.metadataExpand)(metadata, false);
+                registry = expanded.registry;
+                registry.setSignedExtensions(payload.signedExtensions, expanded.definition.userExtensions);
+            }
+            else {
+                // we have no metadata, create a new registry
+                registry = new types_1.TypeRegistry();
+                registry.setSignedExtensions(payload.signedExtensions);
+            }
+        }
+        else {
+            // for non-payload, just create a registry to use
+            registry = new types_1.TypeRegistry();
+        }
+        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
+            this.#cachedUnlocks[pair.address] = Date.now() + defaults_1.PASSWORD_EXPIRY_MS;
+        }
+        else {
+            pair.lock();
+        }
+        resolve({
+            id,
+            ...result
+        });
+        return true;
+    }
+    signingApproveSignature({ id, signature, signedTransaction }) {
+        const queued = this.#state.getSignRequest(id);
+        (0, util_1.assert)(queued, 'Unable to find request');
+        const { resolve } = queued;
+        resolve({ id, signature, signedTransaction });
+        return true;
+    }
+    signingCancel({ id }) {
+        const queued = this.#state.getSignRequest(id);
+        (0, util_1.assert)(queued, 'Unable to find request');
+        const { reject } = queued;
+        reject(new Error('Cancelled'));
+        return true;
+    }
+    signingIsLocked({ id }) {
+        const queued = this.#state.getSignRequest(id);
+        (0, util_1.assert)(queued, 'Unable to find request');
+        const address = queued.request.payload.address;
+        const pair = ui_keyring_1.keyring.getPair(address);
+        (0, util_1.assert)(pair, 'Unable to find pair');
+        const remainingTime = this.refreshAccountPasswordCache(pair);
+        return {
+            isLocked: pair.isLocked,
+            remainingTime
+        };
+    }
+    // FIXME This looks very much like what we have in authorization
+    signingSubscribe(id, port) {
+        const cb = (0, subscriptions_js_1.createSubscription)(id, port);
+        const subscription = this.#state.signSubject.subscribe((requests) => cb(requests));
+        port.onDisconnect.addListener(() => {
+            (0, subscriptions_js_1.unsubscribe)(id);
+            subscription.unsubscribe();
+        });
+        return true;
+    }
+    windowOpen(path) {
+        const url = `${chrome.runtime.getURL('index.html')}#${path}`;
+        if (!defaults_1.ALLOWED_PATH.includes(path)) {
+            console.error('Not allowed to open the url:', url);
+            return false;
+        }
+        (0, helpers_js_1.withErrorLog)(() => chrome.tabs.create({ url }));
+        return true;
+    }
+    derive(parentAddress, suri, password, metadata) {
+        const parentPair = ui_keyring_1.keyring.getPair(parentAddress);
+        try {
+            parentPair.decodePkcs8(password);
+        }
+        catch {
+            throw new Error('invalid password');
+        }
+        try {
+            return parentPair.derive(suri, metadata);
+        }
+        catch {
+            throw new Error(`"${suri}" is not a valid derivation path`);
+        }
+    }
+    derivationValidate({ parentAddress, parentPassword, suri }) {
+        const childPair = this.derive(parentAddress, suri, parentPassword, {});
+        return {
+            address: childPair.address,
+            suri
+        };
+    }
+    derivationCreate({ genesisHash, name, parentAddress, parentPassword, password, suri }) {
+        const childPair = this.derive(parentAddress, suri, parentPassword, {
+            genesisHash,
+            name,
+            parentAddress,
+            suri
+        });
+        ui_keyring_1.keyring.addPair(childPair, password);
+        return true;
+    }
+    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.
+    rejectAuthRequest(id) {
+        const queued = this.#state.getAuthRequest(id);
+        (0, util_1.assert)(queued, 'Unable to find request');
+        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.
+    cancelAuthRequest(id) {
+        const queued = this.#state.getAuthRequest(id);
+        (0, util_1.assert)(queued, 'Unable to find request');
+        const { reject } = queued;
+        reject(new Error('Cancelled'));
+    }
+    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
+    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}`);
+        }
+    }
+}
+exports.default = Extension;