@polkadot/extension-base 0.45.5 → 0.46.2

package/background/RequestBytesSign.d.ts

@@ -1,8 +1,8 @@
 import type { KeyringPair } from '@polkadot/keyring/types';
+import type { TypeRegistry } from '@polkadot/types';
 import type { SignerPayloadRaw } from '@polkadot/types/types';
 import type { HexString } from '@polkadot/util/types';
 import type { RequestSign } from './types.js';
-import { TypeRegistry } from '@polkadot/types';
 export default class RequestBytesSign implements RequestSign {
     readonly payload: SignerPayloadRaw;
     constructor(payload: SignerPayloadRaw);

package/background/RequestExtrinsicSign.d.ts

@@ -1,8 +1,8 @@
 import type { KeyringPair } from '@polkadot/keyring/types';
+import type { TypeRegistry } from '@polkadot/types';
 import type { SignerPayloadJSON } from '@polkadot/types/types';
 import type { HexString } from '@polkadot/util/types';
 import type { RequestSign } from './types.js';
-import { TypeRegistry } from '@polkadot/types';
 export default class RequestExtrinsicSign implements RequestSign {
     readonly payload: SignerPayloadJSON;
     constructor(payload: SignerPayloadJSON);

package/background/handlers/Extension.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="chrome" />
 import type { MessageTypes, RequestTypes, ResponseType } from '../types.js';
-import State from './State.js';
+import type State from './State.js';
 export default class Extension {
     #private;
     constructor(state: State);

package/background/handlers/Extension.js

@@ -1,5 +1,3 @@
-var _Extension_cachedUnlocks, _Extension_state;
-import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 import { ALLOWED_PATH, PASSWORD_EXPIRY_MS } from '@polkadot/extension-base/defaults';
 import { metadataExpand } from '@polkadot/extension-chains';
 import { TypeRegistry } from '@polkadot/types';
@@ -22,15 +20,13 @@ function isJsonPayload(value) {
 }
 export default class Extension {
     constructor(state) {
-        _Extension_cachedUnlocks.set(this, void 0);
-        _Extension_state.set(this, void 0);
-        __classPrivateFieldSet(this, _Extension_cachedUnlocks, {}, "f");
-        __classPrivateFieldSet(this, _Extension_state, state, "f");
+        this.__internal__cachedUnlocks = {};
+        this.__internal__state = state;
     }
     transformAccounts(accounts) {
         return Object.values(accounts).map(({ json: { address, meta }, type }) => ({
             address,
-            isDefaultAuthSelected: __classPrivateFieldGet(this, _Extension_state, "f").defaultAuthAccountSelection.includes(address),
+            isDefaultAuthSelected: this.__internal__state.defaultAuthAccountSelection.includes(address),
             ...meta,
             type
         }));
@@ -79,25 +75,25 @@ export default class Extension {
     accountsForget({ address }) {
         const authorizedAccountsDiff = [];
         // cycle through authUrls and prepare the array of diff
-        Object.entries(__classPrivateFieldGet(this, _Extension_state, "f").authUrls).forEach(([url, urlInfo]) => {
+        Object.entries(this.__internal__state.authUrls).forEach(([url, urlInfo]) => {
             if (!urlInfo.authorizedAccounts.includes(address)) {
                 return;
             }
             authorizedAccountsDiff.push([url, urlInfo.authorizedAccounts.filter((previousAddress) => previousAddress !== address)]);
         });
-        __classPrivateFieldGet(this, _Extension_state, "f").updateAuthorizedAccounts(authorizedAccountsDiff);
+        this.__internal__state.updateAuthorizedAccounts(authorizedAccountsDiff);
         // cycle through default account selection for auth and remove any occurence of the account
-        const newDefaultAuthAccounts = __classPrivateFieldGet(this, _Extension_state, "f").defaultAuthAccountSelection.filter((defaultSelectionAddress) => defaultSelectionAddress !== address);
-        __classPrivateFieldGet(this, _Extension_state, "f").updateDefaultAuthAccounts(newDefaultAuthAccounts);
+        const newDefaultAuthAccounts = this.__internal__state.defaultAuthAccountSelection.filter((defaultSelectionAddress) => defaultSelectionAddress !== address);
+        this.__internal__state.updateDefaultAuthAccounts(newDefaultAuthAccounts);
         keyring.forgetAccount(address);
         return true;
     }
     refreshAccountPasswordCache(pair) {
         const { address } = pair;
-        const savedExpiry = __classPrivateFieldGet(this, _Extension_cachedUnlocks, "f")[address] || 0;
+        const savedExpiry = this.__internal__cachedUnlocks[address] || 0;
         const remainingTime = savedExpiry - Date.now();
         if (remainingTime < 0) {
-            __classPrivateFieldGet(this, _Extension_cachedUnlocks, "f")[address] = 0;
+            this.__internal__cachedUnlocks[address] = 0;
             pair.lock();
             return 0;
         }
@@ -134,22 +130,22 @@ export default class Extension {
         return true;
     }
     authorizeApprove({ authorizedAccounts, id }) {
-        const queued = __classPrivateFieldGet(this, _Extension_state, "f").getAuthRequest(id);
+        const queued = this.__internal__state.getAuthRequest(id);
         assert(queued, 'Unable to find request');
         const { resolve } = queued;
         resolve({ authorizedAccounts, result: true });
         return true;
     }
     authorizeUpdate({ authorizedAccounts, url }) {
-        return __classPrivateFieldGet(this, _Extension_state, "f").updateAuthorizedAccounts([[url, authorizedAccounts]]);
+        return this.__internal__state.updateAuthorizedAccounts([[url, authorizedAccounts]]);
     }
     getAuthList() {
-        return { list: __classPrivateFieldGet(this, _Extension_state, "f").authUrls };
+        return { list: this.__internal__state.authUrls };
     }
     // FIXME This looks very much like what we have in accounts
     authorizeSubscribe(id, port) {
         const cb = createSubscription(id, port);
-        const subscription = __classPrivateFieldGet(this, _Extension_state, "f").authSubject.subscribe((requests) => cb(requests));
+        const subscription = this.__internal__state.authSubject.subscribe((requests) => cb(requests));
         port.onDisconnect.addListener(() => {
             unsubscribe(id);
             subscription.unsubscribe();
@@ -157,21 +153,21 @@ export default class Extension {
         return true;
     }
     metadataApprove({ id }) {
-        const queued = __classPrivateFieldGet(this, _Extension_state, "f").getMetaRequest(id);
+        const queued = this.__internal__state.getMetaRequest(id);
         assert(queued, 'Unable to find request');
         const { request, resolve } = queued;
-        __classPrivateFieldGet(this, _Extension_state, "f").saveMetadata(request);
+        this.__internal__state.saveMetadata(request);
         resolve(true);
         return true;
     }
     metadataGet(genesisHash) {
-        return __classPrivateFieldGet(this, _Extension_state, "f").knownMetadata.find((result) => result.genesisHash === genesisHash) || null;
+        return this.__internal__state.knownMetadata.find((result) => result.genesisHash === genesisHash) || null;
     }
     metadataList() {
-        return __classPrivateFieldGet(this, _Extension_state, "f").knownMetadata;
+        return this.__internal__state.knownMetadata;
     }
     metadataReject({ id }) {
-        const queued = __classPrivateFieldGet(this, _Extension_state, "f").getMetaRequest(id);
+        const queued = this.__internal__state.getMetaRequest(id);
         assert(queued, 'Unable to find request');
         const { reject } = queued;
         reject(new Error('Rejected'));
@@ -179,7 +175,7 @@ export default class Extension {
     }
     metadataSubscribe(id, port) {
         const cb = createSubscription(id, port);
-        const subscription = __classPrivateFieldGet(this, _Extension_state, "f").metaSubject.subscribe((requests) => cb(requests));
+        const subscription = this.__internal__state.metaSubject.subscribe((requests) => cb(requests));
         port.onDisconnect.addListener(() => {
             unsubscribe(id);
             subscription.unsubscribe();
@@ -240,7 +236,7 @@ export default class Extension {
         };
     }
     signingApprovePassword({ id, password, savePass }) {
-        const queued = __classPrivateFieldGet(this, _Extension_state, "f").getSignRequest(id);
+        const queued = this.__internal__state.getSignRequest(id);
         assert(queued, 'Unable to find request');
         const { reject, request, resolve } = queued;
         const pair = keyring.getPair(queued.account.address);
@@ -261,7 +257,7 @@ export default class Extension {
         const { payload } = request;
         if (isJsonPayload(payload)) {
             // Get the metadata for the genesisHash
-            const metadata = __classPrivateFieldGet(this, _Extension_state, "f").knownMetadata.find(({ genesisHash }) => genesisHash === payload.genesisHash);
+            const metadata = this.__internal__state.knownMetadata.find(({ genesisHash }) => genesisHash === payload.genesisHash);
             if (metadata) {
                 // we have metadata, expand it and extract the info/registry
                 const expanded = metadataExpand(metadata, false);
@@ -283,7 +279,7 @@ export default class Extension {
             // unlike queued.account.address the following
             // address is encoded with the default prefix
             // which what is used for password caching mapping
-            __classPrivateFieldGet(this, _Extension_cachedUnlocks, "f")[pair.address] = Date.now() + PASSWORD_EXPIRY_MS;
+            this.__internal__cachedUnlocks[pair.address] = Date.now() + PASSWORD_EXPIRY_MS;
         }
         else {
             pair.lock();
@@ -295,21 +291,21 @@ export default class Extension {
         return true;
     }
     signingApproveSignature({ id, signature }) {
-        const queued = __classPrivateFieldGet(this, _Extension_state, "f").getSignRequest(id);
+        const queued = this.__internal__state.getSignRequest(id);
         assert(queued, 'Unable to find request');
         const { resolve } = queued;
         resolve({ id, signature });
         return true;
     }
     signingCancel({ id }) {
-        const queued = __classPrivateFieldGet(this, _Extension_state, "f").getSignRequest(id);
+        const queued = this.__internal__state.getSignRequest(id);
         assert(queued, 'Unable to find request');
         const { reject } = queued;
         reject(new Error('Cancelled'));
         return true;
     }
     signingIsLocked({ id }) {
-        const queued = __classPrivateFieldGet(this, _Extension_state, "f").getSignRequest(id);
+        const queued = this.__internal__state.getSignRequest(id);
         assert(queued, 'Unable to find request');
         const address = queued.request.payload.address;
         const pair = keyring.getPair(address);
@@ -323,7 +319,7 @@ export default class Extension {
     // FIXME This looks very much like what we have in authorization
     signingSubscribe(id, port) {
         const cb = createSubscription(id, port);
-        const subscription = __classPrivateFieldGet(this, _Extension_state, "f").signSubject.subscribe((requests) => cb(requests));
+        const subscription = this.__internal__state.signSubject.subscribe((requests) => cb(requests));
         port.onDisconnect.addListener(() => {
             unsubscribe(id);
             subscription.unsubscribe();
@@ -372,16 +368,16 @@ export default class Extension {
         return true;
     }
     removeAuthorization(url) {
-        return { list: __classPrivateFieldGet(this, _Extension_state, "f").removeAuthorization(url) };
+        return { list: this.__internal__state.removeAuthorization(url) };
     }
     deleteAuthRequest(requestId) {
-        return __classPrivateFieldGet(this, _Extension_state, "f").deleteAuthRequest(requestId);
+        return this.__internal__state.deleteAuthRequest(requestId);
     }
     updateCurrentTabs({ urls }) {
-        __classPrivateFieldGet(this, _Extension_state, "f").udateCurrentTabsUrl(urls);
+        this.__internal__state.udateCurrentTabsUrl(urls);
     }
     getConnectedTabsUrl() {
-        return __classPrivateFieldGet(this, _Extension_state, "f").getConnectedTabsUrl();
+        return this.__internal__state.getConnectedTabsUrl();
     }
     // Weird thought, the eslint override is not needed in Tabs
     // eslint-disable-next-line @typescript-eslint/require-await
@@ -454,7 +450,7 @@ export default class Extension {
             case 'pri(seed.validate)':
                 return this.seedValidate(request);
             case 'pri(settings.notification)':
-                return __classPrivateFieldGet(this, _Extension_state, "f").setNotification(request);
+                return this.__internal__state.setNotification(request);
             case 'pri(signing.approve.password)':
                 return this.signingApprovePassword(request);
             case 'pri(signing.approve.signature)':
@@ -472,4 +468,3 @@ export default class Extension {
         }
     }
 }
-_Extension_cachedUnlocks = new WeakMap(), _Extension_state = new WeakMap();

package/background/handlers/State.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="chrome" />
 import type { MetadataDef, ProviderMeta } from '@polkadot/extension-inject/types';
 import type { JsonRpcResponse, ProviderInterface, ProviderInterfaceCallback } from '@polkadot/rpc-provider/types';
-import type { AccountJson, AuthorizeRequest, MetadataRequest, RequestAuthorizeTab, RequestRpcSend, RequestRpcSubscribe, RequestRpcUnsubscribe, RequestSign, ResponseRpcListProviders, ResponseSigning, SigningRequest } from '../types.js';
+import type { AccountJson, AuthorizeRequest, AuthUrlInfo, AuthUrls, MetadataRequest, RequestAuthorizeTab, RequestRpcSend, RequestRpcSubscribe, RequestRpcUnsubscribe, RequestSign, ResponseRpcListProviders, ResponseSigning, SigningRequest } from '../types.js';
 import { BehaviorSubject } from 'rxjs';
 interface Resolver<T> {
     reject: (error: Error) => void;
@@ -13,16 +13,7 @@ interface AuthRequest extends Resolver<AuthResponse> {
     request: RequestAuthorizeTab;
     url: string;
 }
-export type AuthUrls = Record<string, AuthUrlInfo>;
 export type AuthorizedAccountsDiff = [url: string, authorizedAccounts: AuthUrlInfo['authorizedAccounts']][];
-export interface AuthUrlInfo {
-    count: number;
-    id: string;
-    isAllowed?: boolean;
-    origin: string;
-    url: string;
-    authorizedAccounts: string[];
-}
 interface MetaRequest extends Resolver<boolean> {
     id: string;
     request: MetadataDef;

package/background/handlers/State.js

@@ -1,12 +1,10 @@
-var _State_authUrls, _State_authRequests, _State_metaStore, _State_injectedProviders, _State_metaRequests, _State_notification, _State_providers, _State_signRequests, _State_windows, _State_connectedTabsUrl;
-import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 import { BehaviorSubject } from 'rxjs';
-import { getId } from '@polkadot/extension-base/utils/getId';
 import { addMetadata, knownMetadata } from '@polkadot/extension-chains';
 import { knownGenesis } from '@polkadot/networks/defaults';
 import settings from '@polkadot/ui-settings';
 import { assert } from '@polkadot/util';
 import { MetadataStore } from '../../stores/index.js';
+import { getId } from '../../utils/getId.js';
 import { withErrorLog } from './helpers.js';
 const NOTIFICATION_URL = chrome.extension.getURL('notification.html');
 const POPUP_WINDOW_OPTS = {
@@ -64,26 +62,24 @@ function extractMetadata(store) {
 }
 export default class State {
     constructor(providers = {}) {
-        _State_authUrls.set(this, {});
-        _State_authRequests.set(this, {});
-        _State_metaStore.set(this, new MetadataStore());
+        this.__internal__authUrls = {};
+        this.__internal__authRequests = {};
+        this.__internal__metaStore = new MetadataStore();
         // Map of providers currently injected in tabs
-        _State_injectedProviders.set(this, new Map());
-        _State_metaRequests.set(this, {});
-        _State_notification.set(this, settings.notification);
-        // Map of all providers exposed by the extension, they are retrievable by key
-        _State_providers.set(this, void 0);
-        _State_signRequests.set(this, {});
-        _State_windows.set(this, []);
-        _State_connectedTabsUrl.set(this, []);
+        this.__internal__injectedProviders = new Map();
+        this.__internal__metaRequests = {};
+        this.__internal__notification = settings.notification;
+        this.__internal__signRequests = {};
+        this.__internal__windows = [];
+        this.__internal__connectedTabsUrl = [];
         this.authSubject = new BehaviorSubject([]);
         this.metaSubject = new BehaviorSubject([]);
         this.signSubject = new BehaviorSubject([]);
         this.defaultAuthAccountSelection = [];
         this.authComplete = (id, resolve, reject) => {
             const complete = (authorizedAccounts = []) => {
-                const { idStr, request: { origin }, url } = __classPrivateFieldGet(this, _State_authRequests, "f")[id];
-                __classPrivateFieldGet(this, _State_authUrls, "f")[this.stripUrl(url)] = {
+                const { idStr, request: { origin }, url } = this.__internal__authRequests[id];
+                this.__internal__authUrls[this.stripUrl(url)] = {
                     authorizedAccounts,
                     count: 0,
                     id: idStr,
@@ -92,7 +88,7 @@ export default class State {
                 };
                 this.saveCurrentAuthList();
                 this.updateDefaultAuthAccounts(authorizedAccounts);
-                delete __classPrivateFieldGet(this, _State_authRequests, "f")[id];
+                delete this.__internal__authRequests[id];
                 this.updateIconAuth(true);
             };
             return {
@@ -108,7 +104,7 @@ export default class State {
         };
         this.metaComplete = (id, resolve, reject) => {
             const complete = () => {
-                delete __classPrivateFieldGet(this, _State_metaRequests, "f")[id];
+                delete this.__internal__metaRequests[id];
                 this.updateIconMeta(true);
             };
             return {
@@ -124,7 +120,7 @@ export default class State {
         };
         this.signComplete = (id, resolve, reject) => {
             const complete = () => {
-                delete __classPrivateFieldGet(this, _State_signRequests, "f")[id];
+                delete this.__internal__signRequests[id];
                 this.updateIconSign(true);
             };
             return {
@@ -138,12 +134,12 @@ export default class State {
                 }
             };
         };
-        __classPrivateFieldSet(this, _State_providers, providers, "f");
-        extractMetadata(__classPrivateFieldGet(this, _State_metaStore, "f"));
+        this.__internal__providers = providers;
+        extractMetadata(this.__internal__metaStore);
         // retrieve previously set authorizations
         const authString = localStorage.getItem(AUTH_URLS_KEY) || '{}';
         const previousAuth = JSON.parse(authString);
-        __classPrivateFieldSet(this, _State_authUrls, previousAuth, "f");
+        this.__internal__authUrls = previousAuth;
         // retrieve previously set default auth accounts
         const defaultAuthString = localStorage.getItem(DEFAULT_AUTH_ACCOUNTS) || '[]';
         const previousDefaultAuth = JSON.parse(defaultAuthString);
@@ -153,43 +149,43 @@ export default class State {
         return knownMetadata();
     }
     get numAuthRequests() {
-        return Object.keys(__classPrivateFieldGet(this, _State_authRequests, "f")).length;
+        return Object.keys(this.__internal__authRequests).length;
     }
     get numMetaRequests() {
-        return Object.keys(__classPrivateFieldGet(this, _State_metaRequests, "f")).length;
+        return Object.keys(this.__internal__metaRequests).length;
     }
     get numSignRequests() {
-        return Object.keys(__classPrivateFieldGet(this, _State_signRequests, "f")).length;
+        return Object.keys(this.__internal__signRequests).length;
     }
     get allAuthRequests() {
         return Object
-            .values(__classPrivateFieldGet(this, _State_authRequests, "f"))
+            .values(this.__internal__authRequests)
             .map(({ id, request, url }) => ({ id, request, url }));
     }
     get allMetaRequests() {
         return Object
-            .values(__classPrivateFieldGet(this, _State_metaRequests, "f"))
+            .values(this.__internal__metaRequests)
             .map(({ id, request, url }) => ({ id, request, url }));
     }
     get allSignRequests() {
         return Object
-            .values(__classPrivateFieldGet(this, _State_signRequests, "f"))
+            .values(this.__internal__signRequests)
             .map(({ account, id, request, url }) => ({ account, id, request, url }));
     }
     get authUrls() {
-        return __classPrivateFieldGet(this, _State_authUrls, "f");
+        return this.__internal__authUrls;
     }
     popupClose() {
-        __classPrivateFieldGet(this, _State_windows, "f").forEach((id) => withErrorLog(() => chrome.windows.remove(id)));
-        __classPrivateFieldSet(this, _State_windows, [], "f");
+        this.__internal__windows.forEach((id) => withErrorLog(() => chrome.windows.remove(id)));
+        this.__internal__windows = [];
     }
     popupOpen() {
-        __classPrivateFieldGet(this, _State_notification, "f") !== 'extension' &&
-            chrome.windows.create(__classPrivateFieldGet(this, _State_notification, "f") === 'window'
+        this.__internal__notification !== 'extension' &&
+            chrome.windows.create(this.__internal__notification === 'window'
                 ? NORMAL_WINDOW_OPTS
                 : POPUP_WINDOW_OPTS, (window) => {
                 if (window) {
-                    __classPrivateFieldGet(this, _State_windows, "f").push(window.id || 0);
+                    this.__internal__windows.push(window.id || 0);
                 }
             });
     }
@@ -209,17 +205,17 @@ export default class State {
                 : undefined;
         })
             .filter((value) => !!value);
-        __classPrivateFieldSet(this, _State_connectedTabsUrl, connectedTabs, "f");
+        this.__internal__connectedTabsUrl = connectedTabs;
     }
     getConnectedTabsUrl() {
-        return __classPrivateFieldGet(this, _State_connectedTabsUrl, "f");
+        return this.__internal__connectedTabsUrl;
     }
     deleteAuthRequest(requestId) {
-        delete __classPrivateFieldGet(this, _State_authRequests, "f")[requestId];
+        delete this.__internal__authRequests[requestId];
         this.updateIconAuth(true);
     }
     saveCurrentAuthList() {
-        localStorage.setItem(AUTH_URLS_KEY, JSON.stringify(__classPrivateFieldGet(this, _State_authUrls, "f")));
+        localStorage.setItem(AUTH_URLS_KEY, JSON.stringify(this.__internal__authUrls));
     }
     saveDefaultAuthAccounts() {
         localStorage.setItem(DEFAULT_AUTH_ACCOUNTS, JSON.stringify(this.defaultAuthAccountSelection));
@@ -248,11 +244,11 @@ export default class State {
         }
     }
     removeAuthorization(url) {
-        const entry = __classPrivateFieldGet(this, _State_authUrls, "f")[url];
+        const entry = this.__internal__authUrls[url];
         assert(entry, `The source ${url} is not known`);
-        delete __classPrivateFieldGet(this, _State_authUrls, "f")[url];
+        delete this.__internal__authUrls[url];
         this.saveCurrentAuthList();
-        return __classPrivateFieldGet(this, _State_authUrls, "f");
+        return this.__internal__authUrls;
     }
     updateIconAuth(shouldClose) {
         this.authSubject.next(this.allAuthRequests);
@@ -268,7 +264,7 @@ export default class State {
     }
     updateAuthorizedAccounts(authorizedAccountDiff) {
         authorizedAccountDiff.forEach(([url, authorizedAccountDiff]) => {
-            __classPrivateFieldGet(this, _State_authUrls, "f")[url].authorizedAccounts = authorizedAccountDiff;
+            this.__internal__authUrls[url].authorizedAccounts = authorizedAccountDiff;
         });
         this.saveCurrentAuthList();
     }
@@ -276,12 +272,12 @@ export default class State {
         const idStr = this.stripUrl(url);
         // Do not enqueue duplicate authorization requests.
         const isDuplicate = Object
-            .values(__classPrivateFieldGet(this, _State_authRequests, "f"))
+            .values(this.__internal__authRequests)
             .some((request) => request.idStr === idStr);
         assert(!isDuplicate, `The source ${url} has a pending authorization request`);
-        if (__classPrivateFieldGet(this, _State_authUrls, "f")[idStr]) {
+        if (this.__internal__authUrls[idStr]) {
             // this url was seen in the past
-            assert(__classPrivateFieldGet(this, _State_authUrls, "f")[idStr].authorizedAccounts || __classPrivateFieldGet(this, _State_authUrls, "f")[idStr].isAllowed, `The source ${url} is not allowed to interact with this extension`);
+            assert(this.__internal__authUrls[idStr].authorizedAccounts || this.__internal__authUrls[idStr].isAllowed, `The source ${url} is not allowed to interact with this extension`);
             return {
                 authorizedAccounts: [],
                 result: false
@@ -289,7 +285,7 @@ export default class State {
         }
         return new Promise((resolve, reject) => {
             const id = getId();
-            __classPrivateFieldGet(this, _State_authRequests, "f")[id] = {
+            this.__internal__authRequests[id] = {
                 ...this.authComplete(id, resolve, reject),
                 id,
                 idStr,
@@ -301,14 +297,14 @@ export default class State {
         });
     }
     ensureUrlAuthorized(url) {
-        const entry = __classPrivateFieldGet(this, _State_authUrls, "f")[this.stripUrl(url)];
+        const entry = this.__internal__authUrls[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();
-            __classPrivateFieldGet(this, _State_metaRequests, "f")[id] = {
+            this.__internal__metaRequests[id] = {
                 ...this.metaComplete(id, resolve, reject),
                 id,
                 request,
@@ -319,73 +315,73 @@ export default class State {
         });
     }
     getAuthRequest(id) {
-        return __classPrivateFieldGet(this, _State_authRequests, "f")[id];
+        return this.__internal__authRequests[id];
     }
     getMetaRequest(id) {
-        return __classPrivateFieldGet(this, _State_metaRequests, "f")[id];
+        return this.__internal__metaRequests[id];
     }
     getSignRequest(id) {
-        return __classPrivateFieldGet(this, _State_signRequests, "f")[id];
+        return this.__internal__signRequests[id];
     }
     // List all providers the extension is exposing
     rpcListProviders() {
-        return Promise.resolve(Object.keys(__classPrivateFieldGet(this, _State_providers, "f")).reduce((acc, key) => {
-            acc[key] = __classPrivateFieldGet(this, _State_providers, "f")[key].meta;
+        return Promise.resolve(Object.keys(this.__internal__providers).reduce((acc, key) => {
+            acc[key] = this.__internal__providers[key].meta;
             return acc;
         }, {}));
     }
     rpcSend(request, port) {
-        const provider = __classPrivateFieldGet(this, _State_injectedProviders, "f").get(port);
+        const provider = this.__internal__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(__classPrivateFieldGet(this, _State_providers, "f")).includes(key), `Provider ${key} is not exposed by extension`);
-        if (__classPrivateFieldGet(this, _State_injectedProviders, "f").get(port)) {
-            return Promise.resolve(__classPrivateFieldGet(this, _State_providers, "f")[key].meta);
+        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);
         }
         // Instantiate the provider
-        __classPrivateFieldGet(this, _State_injectedProviders, "f").set(port, __classPrivateFieldGet(this, _State_providers, "f")[key].start());
+        this.__internal__injectedProviders.set(port, this.__internal__providers[key].start());
         // Close provider connection when page is closed
         port.onDisconnect.addListener(() => {
-            const provider = __classPrivateFieldGet(this, _State_injectedProviders, "f").get(port);
+            const provider = this.__internal__injectedProviders.get(port);
             if (provider) {
                 withErrorLog(() => provider.disconnect());
             }
-            __classPrivateFieldGet(this, _State_injectedProviders, "f").delete(port);
+            this.__internal__injectedProviders.delete(port);
         });
-        return Promise.resolve(__classPrivateFieldGet(this, _State_providers, "f")[key].meta);
+        return Promise.resolve(this.__internal__providers[key].meta);
     }
     rpcSubscribe({ method, params, type }, cb, port) {
-        const provider = __classPrivateFieldGet(this, _State_injectedProviders, "f").get(port);
+        const provider = this.__internal__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 = __classPrivateFieldGet(this, _State_injectedProviders, "f").get(port);
+        const provider = this.__internal__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 = __classPrivateFieldGet(this, _State_injectedProviders, "f").get(port);
+        const provider = this.__internal__injectedProviders.get(port);
         assert(provider, 'Cannot call pub(rpc.unsubscribe) before provider is set');
         return provider.unsubscribe(request.type, request.method, request.subscriptionId);
     }
     saveMetadata(meta) {
-        __classPrivateFieldGet(this, _State_metaStore, "f").set(meta.genesisHash, meta);
+        this.__internal__metaStore.set(meta.genesisHash, meta);
         addMetadata(meta);
     }
     setNotification(notification) {
-        __classPrivateFieldSet(this, _State_notification, notification, "f");
+        this.__internal__notification = notification;
         return true;
     }
     sign(url, request, account) {
         const id = getId();
         return new Promise((resolve, reject) => {
-            __classPrivateFieldGet(this, _State_signRequests, "f")[id] = {
+            this.__internal__signRequests[id] = {
                 ...this.signComplete(id, resolve, reject),
                 account,
                 id,
@@ -397,4 +393,3 @@ export default class State {
         });
     }
 }
-_State_authUrls = new WeakMap(), _State_authRequests = new WeakMap(), _State_metaStore = new WeakMap(), _State_injectedProviders = new WeakMap(), _State_metaRequests = new WeakMap(), _State_notification = new WeakMap(), _State_providers = new WeakMap(), _State_signRequests = new WeakMap(), _State_windows = new WeakMap(), _State_connectedTabsUrl = new WeakMap();

package/background/handlers/Tabs.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="chrome" />
 import type { MessageTypes, RequestTypes, ResponseTypes } from '../types.js';
-import State from './State.js';
+import type State from './State.js';
 export default class Tabs {
     #private;
     constructor(state: State);