@pezkuwi/extension-base 0.62.13 → 0.62.18

package/background/handlers/State.js

@@ -1,478 +0,0 @@
-import { BehaviorSubject } from 'rxjs';
-import { addMetadata, knownMetadata } from '@pezkuwi/extension-chains';
-import { knownGenesis } from '@pezkuwi/networks/defaults';
-import { settings } from '@pezkuwi/ui-settings';
-import { assert } from '@pezkuwi/util';
-import { MetadataStore } from '../../stores/index.js';
-import { getId } from '../../utils/getId.js';
-import { withErrorLog } from './helpers.js';
-const NOTIFICATION_URL = chrome.runtime.getURL('notification.html');
-const POPUP_WINDOW_OPTS = {
-    focused: true,
-    height: 621,
-    left: 150,
-    top: 150,
-    type: 'popup',
-    url: NOTIFICATION_URL,
-    width: 560
-};
-const NORMAL_WINDOW_OPTS = {
-    focused: true,
-    type: 'normal',
-    url: NOTIFICATION_URL
-};
-export var NotificationOptions;
-(function (NotificationOptions) {
-    NotificationOptions[NotificationOptions["None"] = 0] = "None";
-    NotificationOptions[NotificationOptions["Normal"] = 1] = "Normal";
-    NotificationOptions[NotificationOptions["PopUp"] = 2] = "PopUp";
-})(NotificationOptions || (NotificationOptions = {}));
-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));
-    });
-}
-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');
-        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);
-        });
-        // 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, (window) => {
-                if (window) {
-                    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.
-   */
-    udateCurrentTabsUrl(urls) {
-        this.updateCurrentTabsUrl(urls);
-    }
-    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);
-            }
-            catch (e) {
-                console.error(e);
-            }
-            // return the stripped url only if this website is known
-            return !!strippedUrl && this.authUrls[strippedUrl]
-                ? strippedUrl
-                : undefined;
-        })
-            .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);
-            }
-        };
-    };
-    signComplete = (id, resolve, reject) => {
-        const complete = () => {
-            delete this.#signRequests[id];
-            this.updateIconSign(true);
-        };
-        return {
-            reject: (error) => {
-                complete();
-                reject(error);
-            },
-            resolve: (result) => {
-                complete();
-                resolve(result);
-            }
-        };
-    };
-    stripUrl(url) {
-        try {
-            const parsedUrl = new URL(url);
-            if (!['http:', 'https:', 'ipfs:', 'ipns:'].includes(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 `${parsedUrl.protocol}//${parsedUrl.hostname}`;
-            }
-            return parsedUrl.origin;
-        }
-        catch (e) {
-            console.error(e);
-            throw new Error('Invalid URL');
-        }
-    }
-    updateIcon(shouldClose) {
-        const authCount = this.numAuthRequests;
-        const metaCount = this.numMetaRequests;
-        const signCount = this.numSignRequests;
-        const text = (authCount
-            ? 'Auth'
-            : metaCount
-                ? 'Meta'
-                : (signCount ? `${signCount}` : ''));
-        withErrorLog(() => chrome.action.setBadgeText({ text }));
-        if (shouldClose && text === '') {
-            this.popupClose();
-        }
-    }
-    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);
-    }
-    updateIconMeta(shouldClose) {
-        this.metaSubject.next(this.allMetaRequests);
-        this.updateIcon(shouldClose);
-    }
-    updateIconSign(shouldClose) {
-        this.signSubject.next(this.allSignRequests);
-        this.updateIcon(shouldClose);
-    }
-    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);
-            }
-        });
-        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();
-        });
-    }
-    ensureUrlAuthorized(url) {
-        const entry = this.#authUrls.get(this.stripUrl(url));
-        assert(entry, `The source ${url} has not been enabled yet`);
-        return true;
-    }
-    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();
-        });
-    }
-    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
-    rpcListProviders() {
-        return Promise.resolve(Object.keys(this.#providers).reduce((acc, key) => {
-            acc[key] = this.#providers[key].meta;
-            return acc;
-        }, {}));
-    }
-    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
-    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
-        this.#injectedProviders.set(port, this.#providers[key].start());
-        // Close provider connection when page is closed
-        port.onDisconnect.addListener(() => {
-            const provider = this.#injectedProviders.get(port);
-            if (provider) {
-                withErrorLog(() => provider.disconnect());
-            }
-            this.#injectedProviders.delete(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);
-    }
-    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', () => 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);
-    }
-    async saveMetadata(meta) {
-        await this.#metaStore.set(meta.genesisHash, meta);
-        addMetadata(meta);
-    }
-    setNotification(notification) {
-        this.#notification = notification;
-        return true;
-    }
-    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 (!this.#lastRequestTimestamps.has(origin) && this.#lastRequestTimestamps.size >= this.#maxEntries) {
-            const oldestKey = this.#lastRequestTimestamps.keys().next().value;
-            oldestKey && this.#lastRequestTimestamps.delete(oldestKey);
-        }
-        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((resolve, reject) => {
-            this.#signRequests[id] = {
-                ...this.signComplete(id, resolve, reject),
-                account,
-                id,
-                request,
-                url
-            };
-            this.updateIconSign();
-            this.popupOpen();
-        });
-    }
-}

package/background/handlers/Tabs.d.ts

@@ -1,25 +0,0 @@
-import type { MessageTypes, RequestTypes, ResponseTypes } from '../types.js';
-import type State from './State.js';
-export default class Tabs {
-    #private;
-    constructor(state: State);
-    private filterForAuthorizedAccounts;
-    private authorize;
-    private accountsListAuthorized;
-    private accountsSubscribeAuthorized;
-    private accountsUnsubscribe;
-    private getSigningPair;
-    private bytesSign;
-    private extrinsicSign;
-    private metadataProvide;
-    private metadataList;
-    private rpcListProviders;
-    private rpcSend;
-    private rpcStartProvider;
-    private rpcSubscribe;
-    private rpcSubscribeConnected;
-    private rpcUnsubscribe;
-    private redirectPhishingLanding;
-    private redirectIfPhishing;
-    handle<TMessageType extends MessageTypes>(id: string, type: TMessageType, request: RequestTypes[TMessageType], url: string, port?: chrome.runtime.Port): Promise<ResponseTypes[keyof ResponseTypes]>;
-}

package/background/handlers/Tabs.js

@@ -1,195 +0,0 @@
-import { combineLatest } from 'rxjs';
-import { checkIfDenied } from '@pezkuwi/phishing';
-import { keyring } from '@pezkuwi/ui-keyring';
-import { accounts as accountsObservable } from '@pezkuwi/ui-keyring/observable/accounts';
-import { assert, isNumber } from '@pezkuwi/util';
-import { PHISHING_PAGE_REDIRECT } from '../../defaults.js';
-import { canDerive } from '../../utils/index.js';
-import RequestBytesSign from '../RequestBytesSign.js';
-import RequestExtrinsicSign from '../RequestExtrinsicSign.js';
-import { withErrorLog } from './helpers.js';
-import { createSubscription, unsubscribe } from './subscriptions.js';
-function transformAccounts(accounts, anyType = false) {
-    return Object
-        .values(accounts)
-        .filter(({ json: { meta: { isHidden } } }) => !isHidden)
-        .filter(({ type }) => anyType ? true : canDerive(type))
-        .sort((a, b) => (a.json.meta.whenCreated || 0) - (b.json.meta.whenCreated || 0))
-        .map(({ json: { address, meta: { genesisHash, name } }, type }) => ({
-        address,
-        genesisHash,
-        name,
-        type
-    }));
-}
-export default class Tabs {
-    #accountSubs = {};
-    #state;
-    constructor(state) {
-        this.#state = state;
-    }
-    filterForAuthorizedAccounts(accounts, url) {
-        const auth = this.#state.authUrls[this.#state.stripUrl(url)];
-        if (!auth) {
-            return [];
-        }
-        return accounts.filter((allAcc) => auth.authorizedAccounts
-            // we have a list, use it
-            ? auth.authorizedAccounts.includes(allAcc.address)
-            // if no authorizedAccounts and isAllowed return all - these are old converted urls
-            : auth.isAllowed);
-    }
-    authorize(url, request) {
-        return this.#state.authorizeUrl(url, request);
-    }
-    accountsListAuthorized(url, { anyType }) {
-        const transformedAccounts = transformAccounts(accountsObservable.subject.getValue(), anyType);
-        return this.filterForAuthorizedAccounts(transformedAccounts, url);
-    }
-    accountsSubscribeAuthorized(url, id, port) {
-        const cb = createSubscription(id, port);
-        const strippedUrl = this.#state.stripUrl(url);
-        const authUrlObservable = this.#state.authUrlSubjects[strippedUrl]?.asObservable();
-        if (!authUrlObservable) {
-            console.error(`No authUrlSubject found for ${strippedUrl}`);
-            return id;
-        }
-        this.#accountSubs[id] = {
-            subscription: combineLatest([accountsObservable.subject, authUrlObservable]).subscribe(([accounts, _authUrlInfo]) => {
-                const transformedAccounts = transformAccounts(accounts);
-                cb(this.filterForAuthorizedAccounts(transformedAccounts, url));
-            }),
-            url
-        };
-        port.onDisconnect.addListener(() => {
-            this.accountsUnsubscribe(url, { id });
-        });
-        return id;
-    }
-    accountsUnsubscribe(url, { id }) {
-        const sub = this.#accountSubs[id];
-        if (!sub || sub.url !== url) {
-            return false;
-        }
-        delete this.#accountSubs[id];
-        unsubscribe(id);
-        sub.subscription.unsubscribe();
-        return true;
-    }
-    getSigningPair(address) {
-        const pair = keyring.getPair(address);
-        assert(pair, 'Unable to find keypair');
-        return pair;
-    }
-    bytesSign(url, request) {
-        const address = request.address;
-        const pair = this.getSigningPair(address);
-        return this.#state.sign(url, new RequestBytesSign(request), { address, ...pair.meta });
-    }
-    extrinsicSign(url, request) {
-        const address = request.address;
-        const pair = this.getSigningPair(address);
-        return this.#state.sign(url, new RequestExtrinsicSign(request), { address, ...pair.meta });
-    }
-    metadataProvide(url, request) {
-        return this.#state.injectMetadata(url, request);
-    }
-    metadataList(_url) {
-        return this.#state.knownMetadata.map(({ genesisHash, specVersion }) => ({
-            genesisHash,
-            specVersion
-        }));
-    }
-    rpcListProviders() {
-        return this.#state.rpcListProviders();
-    }
-    rpcSend(request, port) {
-        return this.#state.rpcSend(request, port);
-    }
-    rpcStartProvider(key, port) {
-        return this.#state.rpcStartProvider(key, port);
-    }
-    async rpcSubscribe(request, id, port) {
-        const innerCb = createSubscription(id, port);
-        const cb = (_error, data) => innerCb(data);
-        const subscriptionId = await this.#state.rpcSubscribe(request, cb, port);
-        port.onDisconnect.addListener(() => {
-            unsubscribe(id);
-            withErrorLog(() => this.rpcUnsubscribe({ ...request, subscriptionId }, port));
-        });
-        return true;
-    }
-    rpcSubscribeConnected(request, id, port) {
-        const innerCb = createSubscription(id, port);
-        const cb = (_error, data) => innerCb(data);
-        this.#state.rpcSubscribeConnected(request, cb, port);
-        port.onDisconnect.addListener(() => {
-            unsubscribe(id);
-        });
-        return Promise.resolve(true);
-    }
-    async rpcUnsubscribe(request, port) {
-        return this.#state.rpcUnsubscribe(request, port);
-    }
-    redirectPhishingLanding(phishingWebsite) {
-        const nonFragment = phishingWebsite.split('#')[0];
-        const encodedWebsite = encodeURIComponent(nonFragment);
-        const url = `${chrome.runtime.getURL('index.html')}#${PHISHING_PAGE_REDIRECT}/${encodedWebsite}`;
-        chrome.tabs.query({ url: nonFragment }, (tabs) => {
-            tabs
-                .map(({ id }) => id)
-                .filter((id) => isNumber(id))
-                .forEach((id) => withErrorLog(() => chrome.tabs.update(id, { url })));
-        });
-    }
-    async redirectIfPhishing(url) {
-        const isInDenyList = await checkIfDenied(url);
-        if (isInDenyList) {
-            this.redirectPhishingLanding(url);
-            return true;
-        }
-        return false;
-    }
-    async handle(id, type, request, url, port) {
-        if (type === 'pub(phishing.redirectIfDenied)') {
-            return this.redirectIfPhishing(url);
-        }
-        if (type !== 'pub(authorize.tab)') {
-            this.#state.ensureUrlAuthorized(url);
-        }
-        switch (type) {
-            case 'pub(authorize.tab)':
-                return this.authorize(url, request);
-            case 'pub(accounts.list)':
-                return this.accountsListAuthorized(url, request);
-            case 'pub(accounts.subscribe)':
-                return port && this.accountsSubscribeAuthorized(url, id, port);
-            case 'pub(accounts.unsubscribe)':
-                return this.accountsUnsubscribe(url, request);
-            case 'pub(bytes.sign)':
-                return this.bytesSign(url, request);
-            case 'pub(extrinsic.sign)':
-                return this.extrinsicSign(url, request);
-            case 'pub(metadata.list)':
-                return this.metadataList(url);
-            case 'pub(metadata.provide)':
-                return this.metadataProvide(url, request);
-            case 'pub(ping)':
-                return Promise.resolve(true);
-            case 'pub(rpc.listProviders)':
-                return this.rpcListProviders();
-            case 'pub(rpc.send)':
-                return port && this.rpcSend(request, port);
-            case 'pub(rpc.startProvider)':
-                return port && this.rpcStartProvider(request, port);
-            case 'pub(rpc.subscribe)':
-                return port && this.rpcSubscribe(request, id, port);
-            case 'pub(rpc.subscribeConnected)':
-                return port && this.rpcSubscribeConnected(request, id, port);
-            case 'pub(rpc.unsubscribe)':
-                return port && this.rpcUnsubscribe(request, port);
-            default:
-                throw new Error(`Unable to handle message of type ${type}`);
-        }
-    }
-}