@pezkuwi/extension-base 0.62.10 → 0.62.13

package/background/handlers/Tabs.js

@@ -1,64 +1,3 @@
-// Copyright 2019-2025 @pezkuwi/extension-base authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Tabs_accountSubs, _Tabs_state;
 import { combineLatest } from 'rxjs';
 import { checkIfDenied } from '@pezkuwi/phishing';
 import { keyring } from '@pezkuwi/ui-keyring';
@@ -70,244 +9,187 @@ 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) {
-    if (anyType === void 0) { anyType = false; }
+function transformAccounts(accounts, anyType = false) {
     return Object
         .values(accounts)
-        .filter(function (_a) {
-        var isHidden = _a.json.meta.isHidden;
-        return !isHidden;
-    })
-        .filter(function (_a) {
-        var type = _a.type;
-        return anyType ? true : canDerive(type);
-    })
-        .sort(function (a, b) { return (a.json.meta.whenCreated || 0) - (b.json.meta.whenCreated || 0); })
-        .map(function (_a) {
-        var _b = _a.json, address = _b.address, _c = _b.meta, genesisHash = _c.genesisHash, name = _c.name, type = _a.type;
-        return ({
-            address: address,
-            genesisHash: genesisHash,
-            name: name,
-            type: type
-        });
-    });
+        .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
+    }));
 }
-var Tabs = /** @class */ (function () {
-    function Tabs(state) {
-        _Tabs_accountSubs.set(this, {});
-        _Tabs_state.set(this, void 0);
-        __classPrivateFieldSet(this, _Tabs_state, state, "f");
+export default class Tabs {
+    #accountSubs = {};
+    #state;
+    constructor(state) {
+        this.#state = state;
     }
-    Tabs.prototype.filterForAuthorizedAccounts = function (accounts, url) {
-        var auth = __classPrivateFieldGet(this, _Tabs_state, "f").authUrls[__classPrivateFieldGet(this, _Tabs_state, "f").stripUrl(url)];
+    filterForAuthorizedAccounts(accounts, url) {
+        const auth = this.#state.authUrls[this.#state.stripUrl(url)];
         if (!auth) {
             return [];
         }
-        return accounts.filter(function (allAcc) {
-            return 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;
-        });
-    };
-    Tabs.prototype.authorize = function (url, request) {
-        return __classPrivateFieldGet(this, _Tabs_state, "f").authorizeUrl(url, request);
-    };
-    Tabs.prototype.accountsListAuthorized = function (url, _a) {
-        var anyType = _a.anyType;
-        var transformedAccounts = transformAccounts(accountsObservable.subject.getValue(), anyType);
+        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);
-    };
-    Tabs.prototype.accountsSubscribeAuthorized = function (url, id, port) {
-        var _this = this;
-        var _a;
-        var cb = createSubscription(id, port);
-        var strippedUrl = __classPrivateFieldGet(this, _Tabs_state, "f").stripUrl(url);
-        var authUrlObservable = (_a = __classPrivateFieldGet(this, _Tabs_state, "f").authUrlSubjects[strippedUrl]) === null || _a === void 0 ? void 0 : _a.asObservable();
+    }
+    accountsSubscribeAuthorized(url, id, port) {
+        const cb = createSubscription(id, port);
+        const strippedUrl = this.#state.stripUrl(url);
+        const authUrlObservable = this.#state.authUrlSubjects[strippedUrl]?.asObservable();
         if (!authUrlObservable) {
-            console.error("No authUrlSubject found for ".concat(strippedUrl));
+            console.error(`No authUrlSubject found for ${strippedUrl}`);
             return id;
         }
-        __classPrivateFieldGet(this, _Tabs_accountSubs, "f")[id] = {
-            subscription: combineLatest([accountsObservable.subject, authUrlObservable]).subscribe(function (_a) {
-                var accounts = _a[0], _authUrlInfo = _a[1];
-                var transformedAccounts = transformAccounts(accounts);
-                cb(_this.filterForAuthorizedAccounts(transformedAccounts, url));
+        this.#accountSubs[id] = {
+            subscription: combineLatest([accountsObservable.subject, authUrlObservable]).subscribe(([accounts, _authUrlInfo]) => {
+                const transformedAccounts = transformAccounts(accounts);
+                cb(this.filterForAuthorizedAccounts(transformedAccounts, url));
             }),
-            url: url
+            url
         };
-        port.onDisconnect.addListener(function () {
-            _this.accountsUnsubscribe(url, { id: id });
+        port.onDisconnect.addListener(() => {
+            this.accountsUnsubscribe(url, { id });
         });
         return id;
-    };
-    Tabs.prototype.accountsUnsubscribe = function (url, _a) {
-        var id = _a.id;
-        var sub = __classPrivateFieldGet(this, _Tabs_accountSubs, "f")[id];
+    }
+    accountsUnsubscribe(url, { id }) {
+        const sub = this.#accountSubs[id];
         if (!sub || sub.url !== url) {
             return false;
         }
-        delete __classPrivateFieldGet(this, _Tabs_accountSubs, "f")[id];
+        delete this.#accountSubs[id];
         unsubscribe(id);
         sub.subscription.unsubscribe();
         return true;
-    };
-    Tabs.prototype.getSigningPair = function (address) {
-        var pair = keyring.getPair(address);
+    }
+    getSigningPair(address) {
+        const pair = keyring.getPair(address);
         assert(pair, 'Unable to find keypair');
         return pair;
-    };
-    Tabs.prototype.bytesSign = function (url, request) {
-        var address = request.address;
-        var pair = this.getSigningPair(address);
-        return __classPrivateFieldGet(this, _Tabs_state, "f").sign(url, new RequestBytesSign(request), __assign({ address: address }, pair.meta));
-    };
-    Tabs.prototype.extrinsicSign = function (url, request) {
-        var address = request.address;
-        var pair = this.getSigningPair(address);
-        return __classPrivateFieldGet(this, _Tabs_state, "f").sign(url, new RequestExtrinsicSign(request), __assign({ address: address }, pair.meta));
-    };
-    Tabs.prototype.metadataProvide = function (url, request) {
-        return __classPrivateFieldGet(this, _Tabs_state, "f").injectMetadata(url, request);
-    };
-    Tabs.prototype.metadataList = function (_url) {
-        return __classPrivateFieldGet(this, _Tabs_state, "f").knownMetadata.map(function (_a) {
-            var genesisHash = _a.genesisHash, specVersion = _a.specVersion;
-            return ({
-                genesisHash: genesisHash,
-                specVersion: specVersion
-            });
-        });
-    };
-    Tabs.prototype.rpcListProviders = function () {
-        return __classPrivateFieldGet(this, _Tabs_state, "f").rpcListProviders();
-    };
-    Tabs.prototype.rpcSend = function (request, port) {
-        return __classPrivateFieldGet(this, _Tabs_state, "f").rpcSend(request, port);
-    };
-    Tabs.prototype.rpcStartProvider = function (key, port) {
-        return __classPrivateFieldGet(this, _Tabs_state, "f").rpcStartProvider(key, port);
-    };
-    Tabs.prototype.rpcSubscribe = function (request, id, port) {
-        return __awaiter(this, void 0, void 0, function () {
-            var innerCb, cb, subscriptionId;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        innerCb = createSubscription(id, port);
-                        cb = function (_error, data) { return innerCb(data); };
-                        return [4 /*yield*/, __classPrivateFieldGet(this, _Tabs_state, "f").rpcSubscribe(request, cb, port)];
-                    case 1:
-                        subscriptionId = _a.sent();
-                        port.onDisconnect.addListener(function () {
-                            unsubscribe(id);
-                            withErrorLog(function () { return _this.rpcUnsubscribe(__assign(__assign({}, request), { subscriptionId: subscriptionId }), port); });
-                        });
-                        return [2 /*return*/, true];
-                }
-            });
+    }
+    bytesSign(url, request) {
+        const address = request.address;
+        const pair = this.getSigningPair(address);
+        return this.#state.sign(url, new RequestBytesSign(request), { address, ...pair.meta });
+    }
+    extrinsicSign(url, request) {
+        const address = request.address;
+        const pair = this.getSigningPair(address);
+        return this.#state.sign(url, new RequestExtrinsicSign(request), { address, ...pair.meta });
+    }
+    metadataProvide(url, request) {
+        return this.#state.injectMetadata(url, request);
+    }
+    metadataList(_url) {
+        return this.#state.knownMetadata.map(({ genesisHash, specVersion }) => ({
+            genesisHash,
+            specVersion
+        }));
+    }
+    rpcListProviders() {
+        return this.#state.rpcListProviders();
+    }
+    rpcSend(request, port) {
+        return this.#state.rpcSend(request, port);
+    }
+    rpcStartProvider(key, port) {
+        return this.#state.rpcStartProvider(key, port);
+    }
+    async rpcSubscribe(request, id, port) {
+        const innerCb = createSubscription(id, port);
+        const cb = (_error, data) => innerCb(data);
+        const subscriptionId = await this.#state.rpcSubscribe(request, cb, port);
+        port.onDisconnect.addListener(() => {
+            unsubscribe(id);
+            withErrorLog(() => this.rpcUnsubscribe({ ...request, subscriptionId }, port));
         });
-    };
-    Tabs.prototype.rpcSubscribeConnected = function (request, id, port) {
-        var innerCb = createSubscription(id, port);
-        var cb = function (_error, data) { return innerCb(data); };
-        __classPrivateFieldGet(this, _Tabs_state, "f").rpcSubscribeConnected(request, cb, port);
-        port.onDisconnect.addListener(function () {
+        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);
-    };
-    Tabs.prototype.rpcUnsubscribe = function (request, port) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, __classPrivateFieldGet(this, _Tabs_state, "f").rpcUnsubscribe(request, port)];
-            });
-        });
-    };
-    Tabs.prototype.redirectPhishingLanding = function (phishingWebsite) {
-        var nonFragment = phishingWebsite.split('#')[0];
-        var encodedWebsite = encodeURIComponent(nonFragment);
-        var url = "".concat(chrome.runtime.getURL('index.html'), "#").concat(PHISHING_PAGE_REDIRECT, "/").concat(encodedWebsite);
-        chrome.tabs.query({ url: nonFragment }, function (tabs) {
+    }
+    async rpcUnsubscribe(request, port) {
+        return this.#state.rpcUnsubscribe(request, port);
+    }
+    redirectPhishingLanding(phishingWebsite) {
+        const nonFragment = phishingWebsite.split('#')[0];
+        const encodedWebsite = encodeURIComponent(nonFragment);
+        const url = `${chrome.runtime.getURL('index.html')}#${PHISHING_PAGE_REDIRECT}/${encodedWebsite}`;
+        chrome.tabs.query({ url: nonFragment }, (tabs) => {
             tabs
-                .map(function (_a) {
-                var id = _a.id;
-                return id;
-            })
-                .filter(function (id) { return isNumber(id); })
-                .forEach(function (id) {
-                return withErrorLog(function () { return chrome.tabs.update(id, { url: url }); });
-            });
-        });
-    };
-    Tabs.prototype.redirectIfPhishing = function (url) {
-        return __awaiter(this, void 0, void 0, function () {
-            var isInDenyList;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, checkIfDenied(url)];
-                    case 1:
-                        isInDenyList = _a.sent();
-                        if (isInDenyList) {
-                            this.redirectPhishingLanding(url);
-                            return [2 /*return*/, true];
-                        }
-                        return [2 /*return*/, false];
-                }
-            });
-        });
-    };
-    Tabs.prototype.handle = function (id, type, request, url, port) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                if (type === 'pub(phishing.redirectIfDenied)') {
-                    return [2 /*return*/, this.redirectIfPhishing(url)];
-                }
-                if (type !== 'pub(authorize.tab)') {
-                    __classPrivateFieldGet(this, _Tabs_state, "f").ensureUrlAuthorized(url);
-                }
-                switch (type) {
-                    case 'pub(authorize.tab)':
-                        return [2 /*return*/, this.authorize(url, request)];
-                    case 'pub(accounts.list)':
-                        return [2 /*return*/, this.accountsListAuthorized(url, request)];
-                    case 'pub(accounts.subscribe)':
-                        return [2 /*return*/, port && this.accountsSubscribeAuthorized(url, id, port)];
-                    case 'pub(accounts.unsubscribe)':
-                        return [2 /*return*/, this.accountsUnsubscribe(url, request)];
-                    case 'pub(bytes.sign)':
-                        return [2 /*return*/, this.bytesSign(url, request)];
-                    case 'pub(extrinsic.sign)':
-                        return [2 /*return*/, this.extrinsicSign(url, request)];
-                    case 'pub(metadata.list)':
-                        return [2 /*return*/, this.metadataList(url)];
-                    case 'pub(metadata.provide)':
-                        return [2 /*return*/, this.metadataProvide(url, request)];
-                    case 'pub(ping)':
-                        return [2 /*return*/, Promise.resolve(true)];
-                    case 'pub(rpc.listProviders)':
-                        return [2 /*return*/, this.rpcListProviders()];
-                    case 'pub(rpc.send)':
-                        return [2 /*return*/, port && this.rpcSend(request, port)];
-                    case 'pub(rpc.startProvider)':
-                        return [2 /*return*/, port && this.rpcStartProvider(request, port)];
-                    case 'pub(rpc.subscribe)':
-                        return [2 /*return*/, port && this.rpcSubscribe(request, id, port)];
-                    case 'pub(rpc.subscribeConnected)':
-                        return [2 /*return*/, port && this.rpcSubscribeConnected(request, id, port)];
-                    case 'pub(rpc.unsubscribe)':
-                        return [2 /*return*/, port && this.rpcUnsubscribe(request, port)];
-                    default:
-                        throw new Error("Unable to handle message of type ".concat(type));
-                }
-                return [2 /*return*/];
-            });
+                .map(({ id }) => id)
+                .filter((id) => isNumber(id))
+                .forEach((id) => withErrorLog(() => chrome.tabs.update(id, { url })));
         });
-    };
-    return Tabs;
-}());
-_Tabs_accountSubs = new WeakMap(), _Tabs_state = new WeakMap();
-export default Tabs;
+    }
+    async redirectIfPhishing(url) {
+        const isInDenyList = await checkIfDenied(url);
+        if (isInDenyList) {
+            this.redirectPhishingLanding(url);
+            return true;
+        }
+        return false;
+    }
+    async handle(id, type, request, url, port) {
+        if (type === 'pub(phishing.redirectIfDenied)') {
+            return this.redirectIfPhishing(url);
+        }
+        if (type !== 'pub(authorize.tab)') {
+            this.#state.ensureUrlAuthorized(url);
+        }
+        switch (type) {
+            case 'pub(authorize.tab)':
+                return this.authorize(url, request);
+            case 'pub(accounts.list)':
+                return this.accountsListAuthorized(url, request);
+            case 'pub(accounts.subscribe)':
+                return port && this.accountsSubscribeAuthorized(url, id, port);
+            case 'pub(accounts.unsubscribe)':
+                return this.accountsUnsubscribe(url, request);
+            case 'pub(bytes.sign)':
+                return this.bytesSign(url, request);
+            case 'pub(extrinsic.sign)':
+                return this.extrinsicSign(url, request);
+            case 'pub(metadata.list)':
+                return this.metadataList(url);
+            case 'pub(metadata.provide)':
+                return this.metadataProvide(url, request);
+            case 'pub(ping)':
+                return Promise.resolve(true);
+            case 'pub(rpc.listProviders)':
+                return this.rpcListProviders();
+            case 'pub(rpc.send)':
+                return port && this.rpcSend(request, port);
+            case 'pub(rpc.startProvider)':
+                return port && this.rpcStartProvider(request, port);
+            case 'pub(rpc.subscribe)':
+                return port && this.rpcSubscribe(request, id, port);
+            case 'pub(rpc.subscribeConnected)':
+                return port && this.rpcSubscribeConnected(request, id, port);
+            case 'pub(rpc.unsubscribe)':
+                return port && this.rpcUnsubscribe(request, port);
+            default:
+                throw new Error(`Unable to handle message of type ${type}`);
+        }
+    }
+}

package/background/handlers/helpers.js

@@ -1,8 +1,6 @@
-// Copyright 2019-2025 @pezkuwi/extension-base authors & contributors
-// SPDX-License-Identifier: Apache-2.0
 export function withErrorLog(fn) {
     try {
-        var p = fn();
+        const p = fn();
         if (p && typeof p === 'object' && typeof p.catch === 'function') {
             p.catch(console.error);
         }

package/background/handlers/index.js

@@ -1,45 +1,40 @@
-// Copyright 2019-2025 @pezkuwi/extension-base authors & contributors
-// SPDX-License-Identifier: Apache-2.0
 import { assert } from '@pezkuwi/util';
 import { PORT_EXTENSION } from '../../defaults.js';
 import Extension from './Extension.js';
 import State from './State.js';
 import Tabs from './Tabs.js';
 export { withErrorLog } from './helpers.js';
-var state = new State();
+const state = new State();
 await state.init();
-var extension = new Extension(state);
-var tabs = new Tabs(state);
-export default function handler(_a, port, extensionPortName) {
-    var _b;
-    var id = _a.id, message = _a.message, request = _a.request;
-    if (extensionPortName === void 0) { extensionPortName = PORT_EXTENSION; }
-    var isExtension = !port || (port === null || port === void 0 ? void 0 : port.name) === extensionPortName;
-    var sender = port === null || port === void 0 ? void 0 : port.sender;
+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?.name === extensionPortName;
+    const sender = port?.sender;
     if (!isExtension && !sender) {
         throw new Error('Unable to extract message sender');
     }
-    var from = isExtension
+    const from = isExtension
         ? 'extension'
-        : (sender === null || sender === void 0 ? void 0 : sender.url) || ((_b = sender === null || sender === void 0 ? void 0 : sender.tab) === null || _b === void 0 ? void 0 : _b.url) || '<unknown>';
-    var source = "".concat(from, ": ").concat(id, ": ").concat(message);
-    console.log(" [in] ".concat(source)); // :: ${JSON.stringify(request)}`);
-    var promise = isExtension
+        : sender?.url || sender?.tab?.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(function (response) {
-        console.log("[out] ".concat(source)); // :: ${JSON.stringify(response)}`);
+        .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: id, response: response });
+        port.postMessage({ id, response });
     })
-        .catch(function (error) {
-        console.log("[err] ".concat(source, ":: ").concat(error.message));
+        .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: id });
+            port.postMessage({ error: error.message, id });
         }
     });
 }

package/background/handlers/subscriptions.js

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

package/background/index.js

@@ -1,3 +1 @@
-// Copyright 2019-2025 @pezkuwi/extension-base authors & contributors
-// SPDX-License-Identifier: Apache-2.0
 export { default as handlers, withErrorLog } from './handlers/index.js';

package/background/types.js

@@ -1,3 +1 @@
-// Copyright 2019-2025 @pezkuwi/extension-base authors & contributors
-// SPDX-License-Identifier: Apache-2.0
 export {};

package/bundle.js

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

package/cjs/background/RequestBytesSign.d.ts

@@ -0,0 +1,12 @@
+import type { KeyringPair } from '@pezkuwi/keyring/types';
+import type { TypeRegistry } from '@pezkuwi/types';
+import type { SignerPayloadRaw } from '@pezkuwi/types/types';
+import type { HexString } from '@pezkuwi/util/types';
+import type { RequestSign } from './types.js';
+export default class RequestBytesSign implements RequestSign {
+    readonly payload: SignerPayloadRaw;
+    constructor(payload: SignerPayloadRaw);
+    sign(_registry: TypeRegistry, pair: KeyringPair): {
+        signature: HexString;
+    };
+}

package/cjs/background/RequestBytesSign.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("@pezkuwi/util");
+class RequestBytesSign {
+    payload;
+    constructor(payload) {
+        this.payload = payload;
+    }
+    sign(_registry, pair) {
+        return {
+            signature: (0, util_1.u8aToHex)(pair.sign((0, util_1.u8aWrapBytes)(this.payload.data)))
+        };
+    }
+}
+exports.default = RequestBytesSign;

package/cjs/background/RequestExtrinsicSign.d.ts

@@ -0,0 +1,12 @@
+import type { KeyringPair } from '@pezkuwi/keyring/types';
+import type { TypeRegistry } from '@pezkuwi/types';
+import type { SignerPayloadJSON } from '@pezkuwi/types/types';
+import type { HexString } from '@pezkuwi/util/types';
+import type { RequestSign } from './types.js';
+export default class RequestExtrinsicSign implements RequestSign {
+    readonly payload: SignerPayloadJSON;
+    constructor(payload: SignerPayloadJSON);
+    sign(registry: TypeRegistry, pair: KeyringPair): {
+        signature: HexString;
+    };
+}

package/cjs/background/RequestExtrinsicSign.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class RequestExtrinsicSign {
+    payload;
+    constructor(payload) {
+        this.payload = payload;
+    }
+    sign(registry, pair) {
+        return registry
+            .createType('ExtrinsicPayload', this.payload, { version: this.payload.version })
+            .sign(pair);
+    }
+}
+exports.default = RequestExtrinsicSign;