@pezkuwi/extension-base 0.62.8

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

@@ -0,0 +1,25 @@
+import type { MessageTypes, RequestTypes, ResponseTypes } from '../types.js';
+import type State from './State.js';
+export default class Tabs {
+    #private;
+    constructor(state: State);
+    private filterForAuthorizedAccounts;
+    private authorize;
+    private accountsListAuthorized;
+    private accountsSubscribeAuthorized;
+    private accountsUnsubscribe;
+    private getSigningPair;
+    private bytesSign;
+    private extrinsicSign;
+    private metadataProvide;
+    private metadataList;
+    private rpcListProviders;
+    private rpcSend;
+    private rpcStartProvider;
+    private rpcSubscribe;
+    private rpcSubscribeConnected;
+    private rpcUnsubscribe;
+    private redirectPhishingLanding;
+    private redirectIfPhishing;
+    handle<TMessageType extends MessageTypes>(id: string, type: TMessageType, request: RequestTypes[TMessageType], url: string, port?: chrome.runtime.Port): Promise<ResponseTypes[keyof ResponseTypes]>;
+}

package/build/background/handlers/Tabs.js

@@ -0,0 +1,313 @@
+// 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';
+import { accounts as accountsObservable } from '@pezkuwi/ui-keyring/observable/accounts';
+import { assert, isNumber } from '@pezkuwi/util';
+import { PHISHING_PAGE_REDIRECT } from '../../defaults.js';
+import { canDerive } from '../../utils/index.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) {
+    if (anyType === void 0) { 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
+        });
+    });
+}
+var Tabs = /** @class */ (function () {
+    function Tabs(state) {
+        _Tabs_accountSubs.set(this, {});
+        _Tabs_state.set(this, void 0);
+        __classPrivateFieldSet(this, _Tabs_state, state, "f");
+    }
+    Tabs.prototype.filterForAuthorizedAccounts = function (accounts, url) {
+        var auth = __classPrivateFieldGet(this, _Tabs_state, "f").authUrls[__classPrivateFieldGet(this, _Tabs_state, "f").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 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();
+        if (!authUrlObservable) {
+            console.error("No authUrlSubject found for ".concat(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));
+            }),
+            url: url
+        };
+        port.onDisconnect.addListener(function () {
+            _this.accountsUnsubscribe(url, { id: id });
+        });
+        return id;
+    };
+    Tabs.prototype.accountsUnsubscribe = function (url, _a) {
+        var id = _a.id;
+        var 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;
+    };
+    Tabs.prototype.getSigningPair = function (address) {
+        var 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];
+                }
+            });
+        });
+    };
+    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 () {
+            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) {
+            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*/];
+            });
+        });
+    };
+    return Tabs;
+}());
+_Tabs_accountSubs = new WeakMap(), _Tabs_state = new WeakMap();
+export default Tabs;

package/build/background/handlers/helpers.d.ts

@@ -0,0 +1 @@
+export declare function withErrorLog(fn: () => unknown): void;

package/build/background/handlers/helpers.js

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

package/build/background/handlers/index.d.ts

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

package/build/background/handlers/index.js

@@ -0,0 +1,45 @@
+// 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();
+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;
+    if (!isExtension && !sender) {
+        throw new Error('Unable to extract message sender');
+    }
+    var 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
+        ? 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)}`);
+        // 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 });
+    })
+        .catch(function (error) {
+        console.log("[err] ".concat(source, ":: ").concat(error.message));
+        // only send message back to port if it's still connected
+        if (port) {
+            port.postMessage({ error: error.message, id: id });
+        }
+    });
+}

package/build/background/handlers/subscriptions.d.ts

@@ -0,0 +1,3 @@
+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/build/background/handlers/subscriptions.js

@@ -0,0 +1,22 @@
+// 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
+export function createSubscription(id, port) {
+    subscriptions[id] = port;
+    return function (subscription) {
+        if (subscriptions[id]) {
+            port.postMessage({ id: id, subscription: subscription });
+        }
+    };
+}
+// clear a previous subscriber
+export function unsubscribe(id) {
+    if (subscriptions[id]) {
+        console.log("Unsubscribing from ".concat(id));
+        delete subscriptions[id];
+    }
+    else {
+        console.error("Unable to unsubscribe from ".concat(id));
+    }
+}

package/build/background/index.d.ts

@@ -0,0 +1 @@
+export { default as handlers, withErrorLog } from './handlers/index.js';

package/build/background/index.js

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