@pezkuwi/extension-base 0.62.14 → 0.62.18

package/cjs/background/handlers/State.js

@@ -1,482 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotificationOptions = void 0;
-const rxjs_1 = require("rxjs");
-const extension_chains_1 = require("@pezkuwi/extension-chains");
-const defaults_1 = require("@pezkuwi/networks/defaults");
-const ui_settings_1 = require("@pezkuwi/ui-settings");
-const util_1 = require("@pezkuwi/util");
-const index_js_1 = require("../../stores/index.js");
-const getId_js_1 = require("../../utils/getId.js");
-const helpers_js_1 = require("./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
-};
-var NotificationOptions;
-(function (NotificationOptions) {
-    NotificationOptions[NotificationOptions["None"] = 0] = "None";
-    NotificationOptions[NotificationOptions["Normal"] = 1] = "Normal";
-    NotificationOptions[NotificationOptions["PopUp"] = 2] = "PopUp";
-})(NotificationOptions || (exports.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(defaults_1.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 }) => (0, extension_chains_1.addMetadata)(def));
-    });
-}
-class State {
-    #authUrls = new Map();
-    #lastRequestTimestamps = new Map();
-    #maxEntries = 10;
-    #rateLimitInterval = 3000; // 3 seconds
-    #authRequests = {};
-    #metaStore = new index_js_1.MetadataStore();
-    // Map of providers currently injected in tabs
-    #injectedProviders = new Map();
-    #metaRequests = {};
-    #notification = ui_settings_1.settings.notification;
-    // Map of all providers exposed by the extension, they are retrievable by key
-    #providers;
-    #signRequests = {};
-    #windows = [];
-    #connectedTabsUrl = [];
-    authSubject = new rxjs_1.BehaviorSubject([]);
-    metaSubject = new rxjs_1.BehaviorSubject([]);
-    signSubject = new rxjs_1.BehaviorSubject([]);
-    authUrlSubjects = {};
-    defaultAuthAccountSelection = [];
-    constructor(providers = {}, rateLimitInterval = 3000) {
-        (0, util_1.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 rxjs_1.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 (0, extension_chains_1.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) => (0, helpers_js_1.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 rxjs_1.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}` : ''));
-        (0, helpers_js_1.withErrorLog)(() => chrome.action.setBadgeText({ text }));
-        if (shouldClose && text === '') {
-            this.popupClose();
-        }
-    }
-    async removeAuthorization(url) {
-        const entry = this.#authUrls.get(url);
-        (0, util_1.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);
-        (0, util_1.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);
-            (0, util_1.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 = (0, getId_js_1.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));
-        (0, util_1.assert)(entry, `The source ${url} has not been enabled yet`);
-        return true;
-    }
-    injectMetadata(url, request) {
-        return new Promise((resolve, reject) => {
-            const id = (0, getId_js_1.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);
-        (0, util_1.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) {
-        (0, util_1.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) {
-                (0, helpers_js_1.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);
-        (0, util_1.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);
-        (0, util_1.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);
-        (0, util_1.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);
-        (0, extension_chains_1.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 = (0, getId_js_1.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();
-        });
-    }
-}
-exports.default = State;

package/cjs/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]>;
-}