@polkadot/extension-base 0.59.2 → 0.61.1

package/cjs/background/handlers/State.js

@@ -66,35 +66,38 @@ async function extractMetadata(store) {
     });
 }
 class State {
-    __internal__authUrls = {};
-    __internal__authRequests = {};
-    __internal__metaStore = new index_js_1.MetadataStore();
+    #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
-    __internal__injectedProviders = new Map();
-    __internal__metaRequests = {};
-    __internal__notification = ui_settings_1.settings.notification;
+    #injectedProviders = new Map();
+    #metaRequests = {};
+    #notification = ui_settings_1.settings.notification;
     // Map of all providers exposed by the extension, they are retrievable by key
-    __internal__providers;
-    __internal__signRequests = {};
-    __internal__windows = [];
-    __internal__connectedTabsUrl = [];
+    #providers;
+    #signRequests = {};
+    #windows = [];
+    #connectedTabsUrl = [];
     authSubject = new rxjs_1.BehaviorSubject([]);
     metaSubject = new rxjs_1.BehaviorSubject([]);
     signSubject = new rxjs_1.BehaviorSubject([]);
     authUrlSubjects = {};
     defaultAuthAccountSelection = [];
     constructor(providers = {}) {
-        this.__internal__providers = providers;
+        this.#providers = providers;
     }
     async init() {
-        await extractMetadata(this.__internal__metaStore);
+        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.__internal__authUrls = previousAuth;
+        this.#authUrls = new Map(Object.entries(previousAuth));
         // Initialize authUrlSubjects for each URL
-        Object.entries(previousAuth).forEach(([url, authInfo]) => {
+        this.#authUrls.forEach((authInfo, url) => {
             this.authUrlSubjects[url] = new rxjs_1.BehaviorSubject(authInfo);
         });
         // retrieve previously set default auth accounts
@@ -107,49 +110,49 @@ class State {
         return (0, extension_chains_1.knownMetadata)();
     }
     get numAuthRequests() {
-        return Object.keys(this.__internal__authRequests).length;
+        return Object.keys(this.#authRequests).length;
     }
     get numMetaRequests() {
-        return Object.keys(this.__internal__metaRequests).length;
+        return Object.keys(this.#metaRequests).length;
     }
     get numSignRequests() {
-        return Object.keys(this.__internal__signRequests).length;
+        return Object.keys(this.#signRequests).length;
     }
     get allAuthRequests() {
         return Object
-            .values(this.__internal__authRequests)
+            .values(this.#authRequests)
             .map(({ id, request, url }) => ({ id, request, url }));
     }
     get allMetaRequests() {
         return Object
-            .values(this.__internal__metaRequests)
+            .values(this.#metaRequests)
             .map(({ id, request, url }) => ({ id, request, url }));
     }
     get allSignRequests() {
         return Object
-            .values(this.__internal__signRequests)
+            .values(this.#signRequests)
             .map(({ account, id, request, url }) => ({ account, id, request, url }));
     }
     get authUrls() {
-        return this.__internal__authUrls;
+        return Object.fromEntries(this.#authUrls);
     }
     popupClose() {
-        this.__internal__windows.forEach((id) => (0, helpers_js_1.withErrorLog)(() => chrome.windows.remove(id)));
-        this.__internal__windows = [];
+        this.#windows.forEach((id) => (0, helpers_js_1.withErrorLog)(() => chrome.windows.remove(id)));
+        this.#windows = [];
     }
     popupOpen() {
-        this.__internal__notification !== 'extension' &&
-            chrome.windows.create(this.__internal__notification === 'window'
+        this.#notification !== 'extension' &&
+            chrome.windows.create(this.#notification === 'window'
                 ? NORMAL_WINDOW_OPTS
                 : POPUP_WINDOW_OPTS, (window) => {
                 if (window) {
-                    this.__internal__windows.push(window.id || 0);
+                    this.#windows.push(window.id || 0);
                 }
             });
     }
     authComplete = (id, resolve, reject) => {
         const complete = async (authorizedAccounts = []) => {
-            const { idStr, request: { origin }, url } = this.__internal__authRequests[id];
+            const { idStr, request: { origin }, url } = this.#authRequests[id];
             const strippedUrl = this.stripUrl(url);
             const authInfo = {
                 authorizedAccounts,
@@ -158,7 +161,7 @@ class State {
                 origin,
                 url
             };
-            this.__internal__authUrls[strippedUrl] = authInfo;
+            this.#authUrls.set(strippedUrl, authInfo);
             if (!this.authUrlSubjects[strippedUrl]) {
                 this.authUrlSubjects[strippedUrl] = new rxjs_1.BehaviorSubject(authInfo);
             }
@@ -167,14 +170,14 @@ class State {
             }
             await this.saveCurrentAuthList();
             await this.updateDefaultAuthAccounts(authorizedAccounts);
-            delete this.__internal__authRequests[id];
+            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.__internal__authRequests[id];
+                    delete this.#authRequests[id];
                     this.updateIconAuth(true);
                     reject(new Error('Connection request was cancelled by the user.'));
                 }
@@ -212,17 +215,17 @@ class State {
                 : undefined;
         })
             .filter((value) => !!value);
-        this.__internal__connectedTabsUrl = connectedTabs;
+        this.#connectedTabsUrl = connectedTabs;
     }
     getConnectedTabsUrl() {
-        return this.__internal__connectedTabsUrl;
+        return this.#connectedTabsUrl;
     }
     deleteAuthRequest(requestId) {
-        delete this.__internal__authRequests[requestId];
+        delete this.#authRequests[requestId];
         this.updateIconAuth(true);
     }
     async saveCurrentAuthList() {
-        await chrome.storage.local.set({ [AUTH_URLS_KEY]: JSON.stringify(this.__internal__authUrls) });
+        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) });
@@ -233,7 +236,7 @@ class State {
     }
     metaComplete = (id, resolve, reject) => {
         const complete = () => {
-            delete this.__internal__metaRequests[id];
+            delete this.#metaRequests[id];
             this.updateIconMeta(true);
         };
         return {
@@ -249,7 +252,7 @@ class State {
     };
     signComplete = (id, resolve, reject) => {
         const complete = () => {
-            delete this.__internal__signRequests[id];
+            delete this.#signRequests[id];
             this.updateIconSign(true);
         };
         return {
@@ -264,9 +267,22 @@ class State {
         };
     };
     stripUrl(url) {
-        (0, util_1.assert)(url && (url.startsWith('http:') || url.startsWith('https:') || url.startsWith('ipfs:') || url.startsWith('ipns:')), `Invalid url ${url}, expected to start with http: or https: or ipfs: or ipns:`);
-        const parts = url.split('/');
-        return parts[2];
+        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;
@@ -283,15 +299,15 @@ class State {
         }
     }
     async removeAuthorization(url) {
-        const entry = this.__internal__authUrls[url];
+        const entry = this.#authUrls.get(url);
         (0, util_1.assert)(entry, `The source ${url} is not known`);
-        delete this.__internal__authUrls[url];
+        this.#authUrls.delete(url);
         await this.saveCurrentAuthList();
         if (this.authUrlSubjects[url]) {
             entry.authorizedAccounts = [];
             this.authUrlSubjects[url].next(entry);
         }
-        return this.__internal__authUrls;
+        return this.authUrls;
     }
     updateIconAuth(shouldClose) {
         this.authSubject.next(this.allAuthRequests);
@@ -307,8 +323,12 @@ class State {
     }
     async updateAuthorizedAccounts(authorizedAccountsDiff) {
         authorizedAccountsDiff.forEach(([url, authorizedAccountDiff]) => {
-            this.__internal__authUrls[url].authorizedAccounts = authorizedAccountDiff;
-            this.authUrlSubjects[url].next(this.__internal__authUrls[url]);
+            const authInfo = this.#authUrls.get(url);
+            if (authInfo) {
+                authInfo.authorizedAccounts = authorizedAccountDiff;
+                this.#authUrls.set(url, authInfo);
+                this.authUrlSubjects[url].next(authInfo);
+            }
         });
         await this.saveCurrentAuthList();
     }
@@ -316,12 +336,13 @@ class State {
         const idStr = this.stripUrl(url);
         // Do not enqueue duplicate authorization requests.
         const isDuplicate = Object
-            .values(this.__internal__authRequests)
+            .values(this.#authRequests)
             .some((request) => request.idStr === idStr);
         (0, util_1.assert)(!isDuplicate, `The source ${url} has a pending authorization request`);
-        if (this.__internal__authUrls[idStr]) {
+        if (this.#authUrls.has(idStr)) {
             // this url was seen in the past
-            (0, util_1.assert)(this.__internal__authUrls[idStr].authorizedAccounts || this.__internal__authUrls[idStr].isAllowed, `The source ${url} is not allowed to interact with this extension`);
+            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
@@ -329,7 +350,7 @@ class State {
         }
         return new Promise((resolve, reject) => {
             const id = (0, getId_js_1.getId)();
-            this.__internal__authRequests[id] = {
+            this.#authRequests[id] = {
                 ...this.authComplete(id, resolve, reject),
                 id,
                 idStr,
@@ -341,14 +362,14 @@ class State {
         });
     }
     ensureUrlAuthorized(url) {
-        const entry = this.__internal__authUrls[this.stripUrl(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.__internal__metaRequests[id] = {
+            this.#metaRequests[id] = {
                 ...this.metaComplete(id, resolve, reject),
                 id,
                 request,
@@ -359,73 +380,92 @@ class State {
         });
     }
     getAuthRequest(id) {
-        return this.__internal__authRequests[id];
+        return this.#authRequests[id];
     }
     getMetaRequest(id) {
-        return this.__internal__metaRequests[id];
+        return this.#metaRequests[id];
     }
     getSignRequest(id) {
-        return this.__internal__signRequests[id];
+        return this.#signRequests[id];
     }
     // List all providers the extension is exposing
     rpcListProviders() {
-        return Promise.resolve(Object.keys(this.__internal__providers).reduce((acc, key) => {
-            acc[key] = this.__internal__providers[key].meta;
+        return Promise.resolve(Object.keys(this.#providers).reduce((acc, key) => {
+            acc[key] = this.#providers[key].meta;
             return acc;
         }, {}));
     }
     rpcSend(request, port) {
-        const provider = this.__internal__injectedProviders.get(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.__internal__providers).includes(key), `Provider ${key} is not exposed by extension`);
-        if (this.__internal__injectedProviders.get(port)) {
-            return Promise.resolve(this.__internal__providers[key].meta);
+        (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.__internal__injectedProviders.set(port, this.__internal__providers[key].start());
+        this.#injectedProviders.set(port, this.#providers[key].start());
         // Close provider connection when page is closed
         port.onDisconnect.addListener(() => {
-            const provider = this.__internal__injectedProviders.get(port);
+            const provider = this.#injectedProviders.get(port);
             if (provider) {
                 (0, helpers_js_1.withErrorLog)(() => provider.disconnect());
             }
-            this.__internal__injectedProviders.delete(port);
+            this.#injectedProviders.delete(port);
         });
-        return Promise.resolve(this.__internal__providers[key].meta);
+        return Promise.resolve(this.#providers[key].meta);
     }
     rpcSubscribe({ method, params, type }, cb, port) {
-        const provider = this.__internal__injectedProviders.get(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.__internal__injectedProviders.get(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.__internal__injectedProviders.get(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.__internal__metaStore.set(meta.genesisHash, meta);
+        await this.#metaStore.set(meta.genesisHash, meta);
         (0, extension_chains_1.addMetadata)(meta);
     }
     setNotification(notification) {
-        this.__internal__notification = 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.__internal__signRequests[id] = {
+            this.#signRequests[id] = {
                 ...this.signComplete(id, resolve, reject),
                 account,
                 id,

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

@@ -20,6 +20,7 @@ export default class Tabs {
     private rpcSubscribeConnected;
     private rpcUnsubscribe;
     private redirectPhishingLanding;
+    private parseUrl;
     private redirectIfPhishing;
     handle<TMessageType extends MessageTypes>(id: string, type: TMessageType, request: RequestTypes[TMessageType], url: string, port?: chrome.runtime.Port): Promise<ResponseTypes[keyof ResponseTypes]>;
 }

package/cjs/background/handlers/Tabs.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const rxjs_1 = require("rxjs");
+const tldts_1 = require("tldts");
 const phishing_1 = require("@polkadot/phishing");
 const ui_keyring_1 = require("@polkadot/ui-keyring");
 const accounts_1 = require("@polkadot/ui-keyring/observable/accounts");
@@ -26,13 +27,13 @@ function transformAccounts(accounts, anyType = false) {
     }));
 }
 class Tabs {
-    __internal__accountSubs = {};
-    __internal__state;
+    #accountSubs = {};
+    #state;
     constructor(state) {
-        this.__internal__state = state;
+        this.#state = state;
     }
     filterForAuthorizedAccounts(accounts, url) {
-        const auth = this.__internal__state.authUrls[this.__internal__state.stripUrl(url)];
+        const auth = this.#state.authUrls[this.#state.stripUrl(url)];
         if (!auth) {
             return [];
         }
@@ -43,7 +44,7 @@ class Tabs {
             : auth.isAllowed);
     }
     authorize(url, request) {
-        return this.__internal__state.authorizeUrl(url, request);
+        return this.#state.authorizeUrl(url, request);
     }
     accountsListAuthorized(url, { anyType }) {
         const transformedAccounts = transformAccounts(accounts_1.accounts.subject.getValue(), anyType);
@@ -51,13 +52,13 @@ class Tabs {
     }
     accountsSubscribeAuthorized(url, id, port) {
         const cb = (0, subscriptions_js_1.createSubscription)(id, port);
-        const strippedUrl = this.__internal__state.stripUrl(url);
-        const authUrlObservable = this.__internal__state.authUrlSubjects[strippedUrl]?.asObservable();
+        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.__internal__accountSubs[id] = {
+        this.#accountSubs[id] = {
             subscription: (0, rxjs_1.combineLatest)([accounts_1.accounts.subject, authUrlObservable]).subscribe(([accounts, _authUrlInfo]) => {
                 const transformedAccounts = transformAccounts(accounts);
                 cb(this.filterForAuthorizedAccounts(transformedAccounts, url));
@@ -70,11 +71,11 @@ class Tabs {
         return id;
     }
     accountsUnsubscribe(url, { id }) {
-        const sub = this.__internal__accountSubs[id];
+        const sub = this.#accountSubs[id];
         if (!sub || sub.url !== url) {
             return false;
         }
-        delete this.__internal__accountSubs[id];
+        delete this.#accountSubs[id];
         (0, subscriptions_js_1.unsubscribe)(id);
         sub.subscription.unsubscribe();
         return true;
@@ -87,35 +88,35 @@ class Tabs {
     bytesSign(url, request) {
         const address = request.address;
         const pair = this.getSigningPair(address);
-        return this.__internal__state.sign(url, new RequestBytesSign_js_1.default(request), { address, ...pair.meta });
+        return this.#state.sign(url, new RequestBytesSign_js_1.default(request), { address, ...pair.meta });
     }
     extrinsicSign(url, request) {
         const address = request.address;
         const pair = this.getSigningPair(address);
-        return this.__internal__state.sign(url, new RequestExtrinsicSign_js_1.default(request), { address, ...pair.meta });
+        return this.#state.sign(url, new RequestExtrinsicSign_js_1.default(request), { address, ...pair.meta });
     }
     metadataProvide(url, request) {
-        return this.__internal__state.injectMetadata(url, request);
+        return this.#state.injectMetadata(url, request);
     }
     metadataList(_url) {
-        return this.__internal__state.knownMetadata.map(({ genesisHash, specVersion }) => ({
+        return this.#state.knownMetadata.map(({ genesisHash, specVersion }) => ({
             genesisHash,
             specVersion
         }));
     }
     rpcListProviders() {
-        return this.__internal__state.rpcListProviders();
+        return this.#state.rpcListProviders();
     }
     rpcSend(request, port) {
-        return this.__internal__state.rpcSend(request, port);
+        return this.#state.rpcSend(request, port);
     }
     rpcStartProvider(key, port) {
-        return this.__internal__state.rpcStartProvider(key, port);
+        return this.#state.rpcStartProvider(key, port);
     }
     async rpcSubscribe(request, id, port) {
         const innerCb = (0, subscriptions_js_1.createSubscription)(id, port);
         const cb = (_error, data) => innerCb(data);
-        const subscriptionId = await this.__internal__state.rpcSubscribe(request, cb, port);
+        const subscriptionId = await this.#state.rpcSubscribe(request, cb, port);
         port.onDisconnect.addListener(() => {
             (0, subscriptions_js_1.unsubscribe)(id);
             (0, helpers_js_1.withErrorLog)(() => this.rpcUnsubscribe({ ...request, subscriptionId }, port));
@@ -125,14 +126,14 @@ class Tabs {
     rpcSubscribeConnected(request, id, port) {
         const innerCb = (0, subscriptions_js_1.createSubscription)(id, port);
         const cb = (_error, data) => innerCb(data);
-        this.__internal__state.rpcSubscribeConnected(request, cb, port);
+        this.#state.rpcSubscribeConnected(request, cb, port);
         port.onDisconnect.addListener(() => {
             (0, subscriptions_js_1.unsubscribe)(id);
         });
         return Promise.resolve(true);
     }
     async rpcUnsubscribe(request, port) {
-        return this.__internal__state.rpcUnsubscribe(request, port);
+        return this.#state.rpcUnsubscribe(request, port);
     }
     redirectPhishingLanding(phishingWebsite) {
         const nonFragment = phishingWebsite.split('#')[0];
@@ -145,6 +146,19 @@ class Tabs {
                 .forEach((id) => (0, helpers_js_1.withErrorLog)(() => chrome.tabs.update(id, { url })));
         });
     }
+    parseUrl(rawUrl) {
+        let from = 'extension';
+        if (rawUrl) {
+            try {
+                const { hostname } = (0, tldts_1.parse)(rawUrl);
+                from = hostname || '<unknown>'; // Only use the hostname
+            }
+            catch {
+                from = '<unknown>';
+            }
+        }
+        return from;
+    }
     async redirectIfPhishing(url) {
         const isInDenyList = await (0, phishing_1.checkIfDenied)(url);
         if (isInDenyList) {
@@ -155,10 +169,11 @@ class Tabs {
     }
     async handle(id, type, request, url, port) {
         if (type === 'pub(phishing.redirectIfDenied)') {
-            return this.redirectIfPhishing(url);
+            const parsedUrl = this.parseUrl(url);
+            return this.redirectIfPhishing(parsedUrl);
         }
         if (type !== 'pub(authorize.tab)') {
-            this.__internal__state.ensureUrlAuthorized(url);
+            this.#state.ensureUrlAuthorized(url);
         }
         switch (type) {
             case 'pub(authorize.tab)':

package/cjs/packageInfo.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.packageInfo = void 0;
-exports.packageInfo = { name: '@polkadot/extension-base', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '0.59.2' };
+exports.packageInfo = { name: '@polkadot/extension-base', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '0.61.1' };

package/cjs/page/PostMessageProvider.js

@@ -10,19 +10,19 @@ let sendRequest;
  * @description Extension provider to be used by dapps
  */
 class PostMessageProvider {
-    __internal__eventemitter;
+    #eventemitter;
     // Whether or not the actual extension background provider is connected
-    __internal__isConnected = false;
+    #isConnected = false;
     // Subscription IDs are (historically) not guaranteed to be globally unique;
     // only unique for a given subscription method; which is why we identify
     // the subscriptions based on subscription id + type
-    __internal__subscriptions = {}; // {[(type,subscriptionId)]: callback}
+    #subscriptions = {}; // {[(type,subscriptionId)]: callback}
     /**
      * @param {function}  sendRequest  The function to be called to send requests to the node
      * @param {function}  subscriptionNotificationHandler  Channel for receiving subscription messages
      */
     constructor(_sendRequest) {
-        this.__internal__eventemitter = new eventemitter3_1.EventEmitter();
+        this.#eventemitter = new eventemitter3_1.EventEmitter();
         sendRequest = _sendRequest;
     }
     get isClonable() {
@@ -62,7 +62,7 @@ class PostMessageProvider {
      * @return {boolean} true if connected
      */
     get isConnected() {
-        return this.__internal__isConnected;
+        return this.#isConnected;
     }
     listProviders() {
         return sendRequest('pub(rpc.listProviders)', undefined);
@@ -74,9 +74,9 @@ class PostMessageProvider {
      * @return unsubscribe function
      */
     on(type, sub) {
-        this.__internal__eventemitter.on(type, sub);
+        this.#eventemitter.on(type, sub);
         return () => {
-            this.__internal__eventemitter.removeListener(type, sub);
+            this.#eventemitter.removeListener(type, sub);
         };
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -86,7 +86,7 @@ class PostMessageProvider {
             const id = await sendRequest('pub(rpc.subscribe)', { method, params, type }, (res) => {
                 subscription.callback(null, res);
             });
-            this.__internal__subscriptions[`${type}::${id}`] = callback;
+            this.#subscriptions[`${type}::${id}`] = callback;
             return id;
         }
         return sendRequest('pub(rpc.send)', { method, params });
@@ -96,17 +96,17 @@ class PostMessageProvider {
      */
     async startProvider(key) {
         // Disconnect from the previous provider
-        this.__internal__isConnected = false;
-        this.__internal__eventemitter.emit('disconnected');
+        this.#isConnected = false;
+        this.#eventemitter.emit('disconnected');
         const meta = await sendRequest('pub(rpc.startProvider)', key);
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
         sendRequest('pub(rpc.subscribeConnected)', null, (connected) => {
-            this.__internal__isConnected = connected;
+            this.#isConnected = connected;
             if (connected) {
-                this.__internal__eventemitter.emit('connected');
+                this.#eventemitter.emit('connected');
             }
             else {
-                this.__internal__eventemitter.emit('disconnected');
+                this.#eventemitter.emit('disconnected');
             }
             return true;
         });
@@ -124,11 +124,11 @@ class PostMessageProvider {
         // the assigned id now does not match what the API user originally received. It has
         // a slight complication in solving - since we cannot rely on the send id, but rather
         // need to find the actual subscription id to map it
-        if ((0, util_1.isUndefined)(this.__internal__subscriptions[subscription])) {
+        if ((0, util_1.isUndefined)(this.#subscriptions[subscription])) {
             l.debug(() => `Unable to find active subscription=${subscription}`);
             return false;
         }
-        delete this.__internal__subscriptions[subscription];
+        delete this.#subscriptions[subscription];
         return this.send(method, [id]);
     }
 }