@polkadot/extension-base 0.44.9 → 0.45.2

package/background/handlers/Tabs.d.ts

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

package/background/handlers/Tabs.js

@@ -1,223 +1,189 @@
-// Copyright 2019-2023 @polkadot/extension authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
+var _Tabs_accountSubs, _Tabs_state;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 import { PHISHING_PAGE_REDIRECT } from '@polkadot/extension-base/defaults';
 import { canDerive } from '@polkadot/extension-base/utils';
 import { checkIfDenied } from '@polkadot/phishing';
 import keyring from '@polkadot/ui-keyring';
 import { accounts as accountsObservable } from '@polkadot/ui-keyring/observable/accounts';
 import { assert, isNumber } from '@polkadot/util';
-import RequestBytesSign from "../RequestBytesSign.js";
-import RequestExtrinsicSign from "../RequestExtrinsicSign.js";
-import { withErrorLog } from "./helpers.js";
-import { createSubscription, unsubscribe } from "./subscriptions.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: {
+    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
-  }) => ({
-    address,
-    genesisHash,
-    name,
-    type
-  }));
+        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)];
-    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);
-    this.#accountSubs[id] = {
-      subscription: accountsObservable.subject.subscribe(accounts => {
-        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);
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  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.extension.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)':
+    constructor(state) {
+        _Tabs_accountSubs.set(this, {});
+        _Tabs_state.set(this, void 0);
+        __classPrivateFieldSet(this, _Tabs_state, state, "f");
+    }
+    filterForAuthorizedAccounts(accounts, url) {
+        const auth = __classPrivateFieldGet(this, _Tabs_state, "f").authUrls[__classPrivateFieldGet(this, _Tabs_state, "f").stripUrl(url)];
+        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 __classPrivateFieldGet(this, _Tabs_state, "f").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);
+        __classPrivateFieldGet(this, _Tabs_accountSubs, "f")[id] = {
+            subscription: accountsObservable.subject.subscribe((accounts) => {
+                const transformedAccounts = transformAccounts(accounts);
+                cb(this.filterForAuthorizedAccounts(transformedAccounts, url));
+            }),
+            url
+        };
+        port.onDisconnect.addListener(() => {
+            this.accountsUnsubscribe(url, { id });
+        });
+        return id;
+    }
+    accountsUnsubscribe(url, { id }) {
+        const sub = __classPrivateFieldGet(this, _Tabs_accountSubs, "f")[id];
+        if (!sub || sub.url !== url) {
+            return false;
+        }
+        delete __classPrivateFieldGet(this, _Tabs_accountSubs, "f")[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 __classPrivateFieldGet(this, _Tabs_state, "f").sign(url, new RequestBytesSign(request), { address, ...pair.meta });
+    }
+    extrinsicSign(url, request) {
+        const address = request.address;
+        const pair = this.getSigningPair(address);
+        return __classPrivateFieldGet(this, _Tabs_state, "f").sign(url, new RequestExtrinsicSign(request), { address, ...pair.meta });
+    }
+    metadataProvide(url, request) {
+        return __classPrivateFieldGet(this, _Tabs_state, "f").injectMetadata(url, request);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    metadataList(url) {
+        return __classPrivateFieldGet(this, _Tabs_state, "f").knownMetadata.map(({ genesisHash, specVersion }) => ({
+            genesisHash,
+            specVersion
+        }));
+    }
+    rpcListProviders() {
+        return __classPrivateFieldGet(this, _Tabs_state, "f").rpcListProviders();
+    }
+    rpcSend(request, port) {
+        return __classPrivateFieldGet(this, _Tabs_state, "f").rpcSend(request, port);
+    }
+    rpcStartProvider(key, port) {
+        return __classPrivateFieldGet(this, _Tabs_state, "f").rpcStartProvider(key, port);
+    }
+    async rpcSubscribe(request, id, port) {
+        const innerCb = createSubscription(id, port);
+        const cb = (_error, data) => innerCb(data);
+        const subscriptionId = await __classPrivateFieldGet(this, _Tabs_state, "f").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);
+        __classPrivateFieldGet(this, _Tabs_state, "f").rpcSubscribeConnected(request, cb, port);
+        port.onDisconnect.addListener(() => {
+            unsubscribe(id);
+        });
         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}`);
-    }
-  }
-}
+    }
+    async rpcUnsubscribe(request, port) {
+        return __classPrivateFieldGet(this, _Tabs_state, "f").rpcUnsubscribe(request, port);
+    }
+    redirectPhishingLanding(phishingWebsite) {
+        const nonFragment = phishingWebsite.split('#')[0];
+        const encodedWebsite = encodeURIComponent(nonFragment);
+        const url = `${chrome.extension.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)') {
+            __classPrivateFieldGet(this, _Tabs_state, "f").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}`);
+        }
+    }
+}
+_Tabs_accountSubs = new WeakMap(), _Tabs_state = new WeakMap();

package/background/handlers/helpers.js

@@ -1,13 +1,11 @@
-// Copyright 2019-2023 @polkadot/extension authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 export function withErrorLog(fn) {
-  try {
-    const p = fn();
-    if (p && typeof p === 'object' && typeof p.catch === 'function') {
-      p.catch(console.error);
+    try {
+        const p = fn();
+        if (p && typeof p === 'object' && typeof p.catch === 'function') {
+            p.catch(console.error);
+        }
+    }
+    catch (e) {
+        console.error(e);
     }
-  } catch (e) {
-    console.error(e);
-  }
 }

package/background/handlers/index.d.ts

@@ -1,3 +1,3 @@
 /// <reference types="chrome" />
-import type { MessageTypes, TransportRequestMessage } from '../types';
+import type { MessageTypes, TransportRequestMessage } from '../types.js';
 export default function handler<TMessageType extends MessageTypes>({ id, message, request }: TransportRequestMessage<TMessageType>, port?: chrome.runtime.Port, extensionPortName?: string): void;

package/background/handlers/index.js

@@ -1,45 +1,35 @@
-// Copyright 2019-2023 @polkadot/extension authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { assert } from '@polkadot/util';
-import { PORT_EXTENSION } from "../../defaults.js";
-import Extension from "./Extension.js";
-import State from "./State.js";
-import Tabs from "./Tabs.js";
+import { PORT_EXTENSION } from '../../defaults.js';
+import Extension from './Extension.js';
+import State from './State.js';
+import Tabs from './Tabs.js';
 const state = new State();
 const extension = new Extension(state);
 const tabs = new Tabs(state);
-export default function handler({
-  id,
-  message,
-  request
-}, port, extensionPortName = PORT_EXTENSION) {
-  const isExtension = !port || (port == null ? void 0 : port.name) === extensionPortName;
-  const sender = port == null ? void 0 : port.sender;
-  const from = isExtension ? 'extension' : sender.tab && sender.tab.url || sender.url || '<unknown>';
-  const source = `${from}: ${id}: ${message}`;
-  console.log(` [in] ${source}`); // :: ${JSON.stringify(request)}`);
-
-  const promise = isExtension ? extension.handle(id, message, request, port) : tabs.handle(id, message, request, from, port);
-  promise.then(response => {
-    console.log(`[out] ${source}`); // :: ${JSON.stringify(response)}`);
-
-    // between the start and the end of the promise, the user may have closed
-    // the tab, in which case port will be undefined
-    assert(port, 'Port has been disconnected');
-    port.postMessage({
-      id,
-      response
+export default function handler({ id, message, request }, port, extensionPortName = PORT_EXTENSION) {
+    const isExtension = !port || port?.name === extensionPortName;
+    const sender = port?.sender;
+    const from = isExtension
+        ? 'extension'
+        : (sender.tab && sender.tab.url) || sender.url || '<unknown>';
+    const source = `${from}: ${id}: ${message}`;
+    console.log(` [in] ${source}`); // :: ${JSON.stringify(request)}`);
+    const promise = isExtension
+        ? extension.handle(id, message, request, port)
+        : tabs.handle(id, message, request, from, port);
+    promise
+        .then((response) => {
+        console.log(`[out] ${source}`); // :: ${JSON.stringify(response)}`);
+        // between the start and the end of the promise, the user may have closed
+        // the tab, in which case port will be undefined
+        assert(port, 'Port has been disconnected');
+        port.postMessage({ id, response });
+    })
+        .catch((error) => {
+        console.log(`[err] ${source}:: ${error.message}`);
+        // only send message back to port if it's still connected
+        if (port) {
+            port.postMessage({ error: error.message, id });
+        }
     });
-  }).catch(error => {
-    console.log(`[err] ${source}:: ${error.message}`);
-
-    // only send message back to port if it's still connected
-    if (port) {
-      port.postMessage({
-        error: error.message,
-        id
-      });
-    }
-  });
 }

package/background/handlers/subscriptions.d.ts

@@ -1,4 +1,4 @@
 /// <reference types="chrome" />
-import type { MessageTypesWithSubscriptions, SubscriptionMessageTypes } from '../types';
+import type { MessageTypesWithSubscriptions, SubscriptionMessageTypes } from '../types.js';
 export declare function createSubscription<TMessageType extends MessageTypesWithSubscriptions>(id: string, port: chrome.runtime.Port): (data: SubscriptionMessageTypes[TMessageType]) => void;
 export declare function unsubscribe(id: string): void;

package/background/handlers/subscriptions.js

@@ -1,27 +1,18 @@
-// Copyright 2019-2023 @polkadot/extension authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 const subscriptions = {};
-
-// return a subscription callback, that will send the data to the caller via the port
 export function createSubscription(id, port) {
-  subscriptions[id] = port;
-  return subscription => {
-    if (subscriptions[id]) {
-      port.postMessage({
-        id,
-        subscription
-      });
-    }
-  };
+    subscriptions[id] = port;
+    return (subscription) => {
+        if (subscriptions[id]) {
+            port.postMessage({ id, subscription });
+        }
+    };
 }
-
-// clear a previous subscriber
 export function unsubscribe(id) {
-  if (subscriptions[id]) {
-    console.log(`Unsubscribing from ${id}`);
-    delete subscriptions[id];
-  } else {
-    console.error(`Unable to unsubscribe from ${id}`);
-  }
+    if (subscriptions[id]) {
+        console.log(`Unsubscribing from ${id}`);
+        delete subscriptions[id];
+    }
+    else {
+        console.error(`Unable to unsubscribe from ${id}`);
+    }
 }

package/background/types.d.ts

@@ -5,8 +5,8 @@ import type { Registry, SignerPayloadJSON, SignerPayloadRaw } from '@polkadot/ty
 import type { KeyringPairs$Json } from '@polkadot/ui-keyring/types';
 import type { HexString } from '@polkadot/util/types';
 import type { KeypairType } from '@polkadot/util-crypto/types';
-import { ALLOWED_PATH } from '../defaults';
-import { AuthResponse, AuthUrls } from './handlers/State';
+import { ALLOWED_PATH } from '../defaults.js';
+import { AuthResponse, AuthUrls } from './handlers/State.js';
 type KeysWithDefinedValues<T> = {
     [K in keyof T]: T[K] extends undefined ? never : K;
 }[keyof T];

package/bundle.d.ts

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

package/bundle.js

@@ -1,4 +1 @@
-// Copyright 2019-2023 @polkadot/extension-base authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-export { packageInfo } from "./packageInfo.js";
+export { packageInfo } from './packageInfo.js';

package/cjs/background/RequestBytesSign.js

@@ -1,22 +1,15 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _wrapBytes = require("@polkadot/extension-dapp/wrapBytes");
-var _util = require("@polkadot/util");
-// Copyright 2019-2023 @polkadot/extension authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
+Object.defineProperty(exports, "__esModule", { value: true });
+const wrapBytes_1 = require("@polkadot/extension-dapp/wrapBytes");
+const util_1 = require("@polkadot/util");
 class RequestBytesSign {
-  constructor(payload) {
-    this.payload = payload;
-  }
-  sign(_registry, pair) {
-    return {
-      signature: (0, _util.u8aToHex)(pair.sign((0, _wrapBytes.wrapBytes)(this.payload.data)))
-    };
-  }
+    constructor(payload) {
+        this.payload = payload;
+    }
+    sign(_registry, pair) {
+        return {
+            signature: (0, util_1.u8aToHex)(pair.sign((0, wrapBytes_1.wrapBytes)(this.payload.data)))
+        };
+    }
 }
 exports.default = RequestBytesSign;