@pezkuwi/extension-base 0.62.8 → 0.62.12

package/cjs/background/handlers/Tabs.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const rxjs_1 = require("rxjs");
+const phishing_1 = require("@pezkuwi/phishing");
+const ui_keyring_1 = require("@pezkuwi/ui-keyring");
+const accounts_1 = require("@pezkuwi/ui-keyring/observable/accounts");
+const util_1 = require("@pezkuwi/util");
+const defaults_js_1 = require("../../defaults.js");
+const index_js_1 = require("../../utils/index.js");
+const RequestBytesSign_js_1 = tslib_1.__importDefault(require("../RequestBytesSign.js"));
+const RequestExtrinsicSign_js_1 = tslib_1.__importDefault(require("../RequestExtrinsicSign.js"));
+const helpers_js_1 = require("./helpers.js");
+const subscriptions_js_1 = require("./subscriptions.js");
+function transformAccounts(accounts, anyType = false) {
+    return Object
+        .values(accounts)
+        .filter(({ json: { meta: { isHidden } } }) => !isHidden)
+        .filter(({ type }) => anyType ? true : (0, index_js_1.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
+    }));
+}
+class Tabs {
+    #accountSubs = {};
+    #state;
+    constructor(state) {
+        this.#state = state;
+    }
+    filterForAuthorizedAccounts(accounts, url) {
+        const auth = this.#state.authUrls[this.#state.stripUrl(url)];
+        if (!auth) {
+            return [];
+        }
+        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(accounts_1.accounts.subject.getValue(), anyType);
+        return this.filterForAuthorizedAccounts(transformedAccounts, url);
+    }
+    accountsSubscribeAuthorized(url, id, port) {
+        const cb = (0, subscriptions_js_1.createSubscription)(id, port);
+        const strippedUrl = this.#state.stripUrl(url);
+        const authUrlObservable = this.#state.authUrlSubjects[strippedUrl]?.asObservable();
+        if (!authUrlObservable) {
+            console.error(`No authUrlSubject found for ${strippedUrl}`);
+            return id;
+        }
+        this.#accountSubs[id] = {
+            subscription: (0, rxjs_1.combineLatest)([accounts_1.accounts.subject, authUrlObservable]).subscribe(([accounts, _authUrlInfo]) => {
+                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];
+        (0, subscriptions_js_1.unsubscribe)(id);
+        sub.subscription.unsubscribe();
+        return true;
+    }
+    getSigningPair(address) {
+        const pair = ui_keyring_1.keyring.getPair(address);
+        (0, util_1.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_js_1.default(request), { address, ...pair.meta });
+    }
+    extrinsicSign(url, request) {
+        const address = request.address;
+        const pair = this.getSigningPair(address);
+        return this.#state.sign(url, new RequestExtrinsicSign_js_1.default(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 = (0, subscriptions_js_1.createSubscription)(id, port);
+        const cb = (_error, data) => innerCb(data);
+        const subscriptionId = await this.#state.rpcSubscribe(request, cb, port);
+        port.onDisconnect.addListener(() => {
+            (0, subscriptions_js_1.unsubscribe)(id);
+            (0, helpers_js_1.withErrorLog)(() => this.rpcUnsubscribe({ ...request, subscriptionId }, port));
+        });
+        return true;
+    }
+    rpcSubscribeConnected(request, id, port) {
+        const innerCb = (0, subscriptions_js_1.createSubscription)(id, port);
+        const cb = (_error, data) => innerCb(data);
+        this.#state.rpcSubscribeConnected(request, cb, port);
+        port.onDisconnect.addListener(() => {
+            (0, subscriptions_js_1.unsubscribe)(id);
+        });
+        return Promise.resolve(true);
+    }
+    async rpcUnsubscribe(request, port) {
+        return this.#state.rpcUnsubscribe(request, port);
+    }
+    redirectPhishingLanding(phishingWebsite) {
+        const nonFragment = phishingWebsite.split('#')[0];
+        const encodedWebsite = encodeURIComponent(nonFragment);
+        const url = `${chrome.runtime.getURL('index.html')}#${defaults_js_1.PHISHING_PAGE_REDIRECT}/${encodedWebsite}`;
+        chrome.tabs.query({ url: nonFragment }, (tabs) => {
+            tabs
+                .map(({ id }) => id)
+                .filter((id) => (0, util_1.isNumber)(id))
+                .forEach((id) => (0, helpers_js_1.withErrorLog)(() => chrome.tabs.update(id, { url })));
+        });
+    }
+    async redirectIfPhishing(url) {
+        const isInDenyList = await (0, phishing_1.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}`);
+        }
+    }
+}
+exports.default = Tabs;

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

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

package/cjs/background/handlers/helpers.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withErrorLog = withErrorLog;
+function withErrorLog(fn) {
+    try {
+        const p = fn();
+        if (p && typeof p === 'object' && typeof p.catch === 'function') {
+            p.catch(console.error);
+        }
+    }
+    catch (e) {
+        console.error(e);
+    }
+}

package/cjs/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/cjs/background/handlers/index.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withErrorLog = void 0;
+exports.default = handler;
+const tslib_1 = require("tslib");
+const util_1 = require("@pezkuwi/util");
+const defaults_js_1 = require("../../defaults.js");
+const Extension_js_1 = tslib_1.__importDefault(require("./Extension.js"));
+const State_js_1 = tslib_1.__importDefault(require("./State.js"));
+const Tabs_js_1 = tslib_1.__importDefault(require("./Tabs.js"));
+var helpers_js_1 = require("./helpers.js");
+Object.defineProperty(exports, "withErrorLog", { enumerable: true, get: function () { return helpers_js_1.withErrorLog; } });
+const state = new State_js_1.default();
+await state.init();
+const extension = new Extension_js_1.default(state);
+const tabs = new Tabs_js_1.default(state);
+function handler({ id, message, request }, port, extensionPortName = defaults_js_1.PORT_EXTENSION) {
+    const isExtension = !port || port?.name === extensionPortName;
+    const sender = port?.sender;
+    if (!isExtension && !sender) {
+        throw new Error('Unable to extract message sender');
+    }
+    const from = isExtension
+        ? 'extension'
+        : 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((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
+        (0, util_1.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 });
+        }
+    });
+}

package/cjs/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/cjs/background/handlers/subscriptions.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSubscription = createSubscription;
+exports.unsubscribe = unsubscribe;
+const subscriptions = {};
+function createSubscription(id, port) {
+    subscriptions[id] = port;
+    return (subscription) => {
+        if (subscriptions[id]) {
+            port.postMessage({ id, subscription });
+        }
+    };
+}
+function unsubscribe(id) {
+    if (subscriptions[id]) {
+        console.log(`Unsubscribing from ${id}`);
+        delete subscriptions[id];
+    }
+    else {
+        console.error(`Unable to unsubscribe from ${id}`);
+    }
+}

package/cjs/background/index.d.ts

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

package/cjs/background/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withErrorLog = exports.handlers = void 0;
+const tslib_1 = require("tslib");
+var index_js_1 = require("./handlers/index.js");
+Object.defineProperty(exports, "handlers", { enumerable: true, get: function () { return tslib_1.__importDefault(index_js_1).default; } });
+Object.defineProperty(exports, "withErrorLog", { enumerable: true, get: function () { return index_js_1.withErrorLog; } });

package/cjs/background/types.d.ts

@@ -0,0 +1,343 @@
+import type { InjectedAccount, InjectedMetadataKnown, MetadataDef, ProviderList, ProviderMeta } from '@pezkuwi/extension-inject/types';
+import type { KeyringPair, KeyringPair$Json, KeyringPair$Meta } from '@pezkuwi/keyring/types';
+import type { JsonRpcResponse } from '@pezkuwi/rpc-provider/types';
+import type { Registry, SignerPayloadJSON, SignerPayloadRaw } from '@pezkuwi/types/types';
+import type { KeyringPairs$Json } from '@pezkuwi/ui-keyring/types';
+import type { HexString } from '@pezkuwi/util/types';
+import type { KeypairType } from '@pezkuwi/util-crypto/types';
+import type { ALLOWED_PATH } from '../defaults.js';
+import type { AuthResponse } from './handlers/State.js';
+type KeysWithDefinedValues<T> = {
+    [K in keyof T]: T[K] extends undefined ? never : K;
+}[keyof T];
+type NoUndefinedValues<T> = {
+    [K in KeysWithDefinedValues<T>]: T[K];
+};
+type IsNull<T, K extends keyof T> = {
+    [K1 in Exclude<keyof T, K>]: T[K1];
+} & T[K] extends null ? K : never;
+type NullKeys<T> = {
+    [K in keyof T]: IsNull<T, K>;
+}[keyof T];
+export type AuthUrls = Record<string, AuthUrlInfo>;
+export interface AuthUrlInfo {
+    count: number;
+    id: string;
+    isAllowed?: boolean;
+    origin: string;
+    url: string;
+    authorizedAccounts: string[];
+}
+export type SeedLengths = 12 | 24;
+export interface AccountJson extends KeyringPair$Meta {
+    address: string;
+}
+export type AccountWithChildren = AccountJson & {
+    children?: AccountWithChildren[];
+};
+export interface AccountsContext {
+    accounts: AccountJson[];
+    hierarchy: AccountWithChildren[];
+    master?: AccountJson;
+    selectedAccounts?: AccountJson['address'][];
+    setSelectedAccounts?: (address: AccountJson['address'][]) => void;
+}
+export interface AuthorizeRequest {
+    id: string;
+    request: RequestAuthorizeTab;
+    url: string;
+}
+export interface MetadataRequest {
+    id: string;
+    request: MetadataDef;
+    url: string;
+}
+export interface SigningRequest {
+    account: AccountJson;
+    id: string;
+    request: RequestSign;
+    url: string;
+}
+export type ConnectedTabsUrlResponse = string[];
+export interface RequestSignatures {
+    'pri(accounts.create.external)': [RequestAccountCreateExternal, boolean];
+    'pri(accounts.create.hardware)': [RequestAccountCreateHardware, boolean];
+    'pri(accounts.create.suri)': [RequestAccountCreateSuri, boolean];
+    'pri(accounts.edit)': [RequestAccountEdit, boolean];
+    'pri(accounts.export)': [RequestAccountExport, ResponseAccountExport];
+    'pri(accounts.batchExport)': [RequestAccountBatchExport, ResponseAccountsExport];
+    'pri(accounts.forget)': [RequestAccountForget, boolean];
+    'pri(accounts.list)': [RequestAccountList, InjectedAccount[]];
+    'pri(accounts.show)': [RequestAccountShow, boolean];
+    'pri(accounts.tie)': [RequestAccountTie, boolean];
+    'pri(accounts.subscribe)': [RequestAccountSubscribe, boolean, AccountJson[]];
+    'pri(accounts.validate)': [RequestAccountValidate, boolean];
+    'pri(accounts.changePassword)': [RequestAccountChangePassword, boolean];
+    'pri(authorize.approve)': [RequestAuthorizeApprove, boolean];
+    'pri(authorize.list)': [null, ResponseAuthorizeList];
+    'pri(authorize.requests)': [RequestAuthorizeSubscribe, boolean, AuthorizeRequest[]];
+    'pri(authorize.remove)': [string, ResponseAuthorizeList];
+    'pri(authorize.reject)': [string, void];
+    'pri(authorize.cancel)': [string, void];
+    'pri(authorize.update)': [RequestUpdateAuthorizedAccounts, void];
+    'pri(activeTabsUrl.update)': [RequestActiveTabsUrlUpdate, void];
+    'pri(connectedTabsUrl.get)': [null, ConnectedTabsUrlResponse];
+    'pri(derivation.create)': [RequestDeriveCreate, boolean];
+    'pri(derivation.validate)': [RequestDeriveValidate, ResponseDeriveValidate];
+    'pri(json.restore)': [RequestJsonRestore, void];
+    'pri(json.batchRestore)': [RequestBatchRestore, void];
+    'pri(json.account.info)': [KeyringPair$Json, ResponseJsonGetAccountInfo];
+    'pri(metadata.approve)': [RequestMetadataApprove, boolean];
+    'pri(metadata.get)': [string | null, MetadataDef | null];
+    'pri(metadata.reject)': [RequestMetadataReject, boolean];
+    'pri(metadata.requests)': [RequestMetadataSubscribe, boolean, MetadataRequest[]];
+    'pri(metadata.list)': [null, MetadataDef[]];
+    'pri(ping)': [null, boolean];
+    'pri(seed.create)': [RequestSeedCreate, ResponseSeedCreate];
+    'pri(seed.validate)': [RequestSeedValidate, ResponseSeedValidate];
+    'pri(settings.notification)': [string, boolean];
+    'pri(signing.approve.password)': [RequestSigningApprovePassword, boolean];
+    'pri(signing.approve.signature)': [RequestSigningApproveSignature, boolean];
+    'pri(signing.cancel)': [RequestSigningCancel, boolean];
+    'pri(signing.isLocked)': [RequestSigningIsLocked, ResponseSigningIsLocked];
+    'pri(signing.requests)': [RequestSigningSubscribe, boolean, SigningRequest[]];
+    'pri(window.open)': [AllowedPath, boolean];
+    'pub(accounts.list)': [RequestAccountList, InjectedAccount[]];
+    'pub(accounts.subscribe)': [RequestAccountSubscribe, string, InjectedAccount[]];
+    'pub(accounts.unsubscribe)': [RequestAccountUnsubscribe, boolean];
+    'pub(authorize.tab)': [RequestAuthorizeTab, Promise<AuthResponse>];
+    'pub(bytes.sign)': [SignerPayloadRaw, ResponseSigning];
+    'pub(extrinsic.sign)': [SignerPayloadJSON, ResponseSigning];
+    'pub(metadata.list)': [null, InjectedMetadataKnown[]];
+    'pub(metadata.provide)': [MetadataDef, boolean];
+    'pub(phishing.redirectIfDenied)': [null, boolean];
+    'pub(ping)': [null, boolean];
+    'pub(rpc.listProviders)': [void, ResponseRpcListProviders];
+    'pub(rpc.send)': [RequestRpcSend, JsonRpcResponse<unknown>];
+    'pub(rpc.startProvider)': [string, ProviderMeta];
+    'pub(rpc.subscribe)': [RequestRpcSubscribe, number, JsonRpcResponse<unknown>];
+    'pub(rpc.subscribeConnected)': [null, boolean, boolean];
+    'pub(rpc.unsubscribe)': [RequestRpcUnsubscribe, boolean];
+}
+export type MessageTypes = keyof RequestSignatures;
+export type RequestTypes = {
+    [MessageType in keyof RequestSignatures]: RequestSignatures[MessageType][0];
+};
+export type MessageTypesWithNullRequest = NullKeys<RequestTypes>;
+export interface TransportRequestMessage<TMessageType extends MessageTypes> {
+    id: string;
+    message: TMessageType;
+    origin: string;
+    request: RequestTypes[TMessageType];
+}
+export interface RequestAuthorizeTab {
+    origin: string;
+}
+export interface RequestAuthorizeApprove {
+    id: string;
+    authorizedAccounts: string[];
+}
+export interface RequestUpdateAuthorizedAccounts {
+    url: string;
+    authorizedAccounts: string[];
+}
+export type RequestAuthorizeSubscribe = null;
+export interface RequestMetadataApprove {
+    id: string;
+}
+export interface RequestMetadataReject {
+    id: string;
+}
+export type RequestMetadataSubscribe = null;
+export interface RequestAccountCreateExternal {
+    address: string;
+    genesisHash?: HexString | null;
+    name: string;
+}
+export interface RequestAccountCreateSuri {
+    name: string;
+    genesisHash?: HexString | null;
+    password: string;
+    suri: string;
+    type?: KeypairType;
+}
+export interface RequestAccountCreateHardware {
+    accountIndex: number;
+    address: string;
+    addressOffset: number;
+    genesisHash: HexString;
+    hardwareType: string;
+    name: string;
+    type: KeypairType;
+}
+export interface RequestAccountChangePassword {
+    address: string;
+    oldPass: string;
+    newPass: string;
+}
+export interface RequestAccountEdit {
+    address: string;
+    genesisHash?: HexString | null;
+    name: string;
+}
+export interface RequestAccountForget {
+    address: string;
+}
+export interface RequestAccountShow {
+    address: string;
+    isShowing: boolean;
+}
+export interface RequestAccountTie {
+    address: string;
+    genesisHash: HexString | null;
+}
+export interface RequestAccountValidate {
+    address: string;
+    password: string;
+}
+export interface RequestDeriveCreate {
+    name: string;
+    genesisHash?: HexString | null;
+    suri: string;
+    parentAddress: string;
+    parentPassword: string;
+    password: string;
+}
+export interface RequestDeriveValidate {
+    suri: string;
+    parentAddress: string;
+    parentPassword: string;
+}
+export interface RequestAccountExport {
+    address: string;
+    password: string;
+}
+export interface RequestAccountBatchExport {
+    addresses: string[];
+    password: string;
+}
+export interface RequestAccountList {
+    anyType?: boolean;
+}
+export type RequestAccountSubscribe = null;
+export interface RequestActiveTabsUrlUpdate {
+    urls: string[];
+}
+export interface RequestAccountUnsubscribe {
+    id: string;
+}
+export interface RequestRpcSend {
+    method: string;
+    params: unknown[];
+}
+export interface RequestRpcSubscribe extends RequestRpcSend {
+    type: string;
+}
+export interface RequestRpcUnsubscribe {
+    method: string;
+    subscriptionId: number | string;
+    type: string;
+}
+export interface RequestSigningApprovePassword {
+    id: string;
+    password?: string;
+    savePass: boolean;
+}
+export interface RequestSigningApproveSignature {
+    id: string;
+    signature: HexString;
+    signedTransaction?: HexString;
+}
+export interface RequestSigningCancel {
+    id: string;
+}
+export interface RequestSigningIsLocked {
+    id: string;
+}
+export interface ResponseSigningIsLocked {
+    isLocked: boolean;
+    remainingTime: number;
+}
+export type RequestSigningSubscribe = null;
+export interface RequestSeedCreate {
+    length?: SeedLengths;
+    seed?: string;
+    type?: KeypairType;
+}
+export interface RequestSeedValidate {
+    suri: string;
+    type?: KeypairType;
+}
+export type ResponseTypes = {
+    [MessageType in keyof RequestSignatures]: RequestSignatures[MessageType][1];
+};
+export type ResponseType<TMessageType extends keyof RequestSignatures> = RequestSignatures[TMessageType][1];
+interface TransportResponseMessageSub<TMessageType extends MessageTypesWithSubscriptions> {
+    error?: string;
+    id: string;
+    response?: ResponseTypes[TMessageType];
+    subscription?: SubscriptionMessageTypes[TMessageType];
+}
+interface TransportResponseMessageNoSub<TMessageType extends MessageTypesWithNoSubscriptions> {
+    error?: string;
+    id: string;
+    response?: ResponseTypes[TMessageType];
+}
+export type TransportResponseMessage<TMessageType extends MessageTypes> = TMessageType extends MessageTypesWithNoSubscriptions ? TransportResponseMessageNoSub<TMessageType> : TMessageType extends MessageTypesWithSubscriptions ? TransportResponseMessageSub<TMessageType> : never;
+export interface ResponseSigning {
+    id: string;
+    signature: HexString;
+    signedTransaction?: HexString;
+}
+export interface ResponseDeriveValidate {
+    address: string;
+    suri: string;
+}
+export interface ResponseSeedCreate {
+    address: string;
+    seed: string;
+}
+export interface ResponseSeedValidate {
+    address: string;
+    suri: string;
+}
+export interface ResponseAccountExport {
+    exportedJson: KeyringPair$Json;
+}
+export interface ResponseAccountsExport {
+    exportedJson: KeyringPairs$Json;
+}
+export type ResponseRpcListProviders = ProviderList;
+export type SubscriptionMessageTypes = NoUndefinedValues<{
+    [MessageType in keyof RequestSignatures]: RequestSignatures[MessageType][2];
+}>;
+export type MessageTypesWithSubscriptions = keyof SubscriptionMessageTypes;
+export type MessageTypesWithNoSubscriptions = Exclude<MessageTypes, keyof SubscriptionMessageTypes>;
+export interface RequestSign {
+    readonly payload: SignerPayloadJSON | SignerPayloadRaw;
+    sign(registry: Registry, pair: KeyringPair): {
+        signature: HexString;
+    };
+}
+export interface RequestJsonRestore {
+    file: KeyringPair$Json;
+    password: string;
+}
+export interface RequestBatchRestore {
+    file: KeyringPairs$Json;
+    password: string;
+}
+export interface ResponseJsonRestore {
+    error: string | null;
+}
+export type AllowedPath = typeof ALLOWED_PATH[number];
+export interface ResponseJsonGetAccountInfo {
+    address: string;
+    name: string;
+    genesisHash: HexString;
+    type: KeypairType;
+}
+export interface ResponseAuthorizeList {
+    list: AuthUrls;
+}
+export {};

package/cjs/background/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/bundle.d.ts

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

package/cjs/bundle.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageInfo = void 0;
+var packageInfo_js_1 = require("./packageInfo.js");
+Object.defineProperty(exports, "packageInfo", { enumerable: true, get: function () { return packageInfo_js_1.packageInfo; } });

package/cjs/defaults.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PHISHING_PAGE_REDIRECT = exports.PASSWORD_EXPIRY_MS = exports.PASSWORD_EXPIRY_MIN = exports.ALLOWED_PATH = exports.MESSAGE_ORIGIN_CONTENT = exports.MESSAGE_ORIGIN_PAGE = exports.PORT_EXTENSION = exports.PORT_CONTENT = exports.EXTENSION_PREFIX = void 0;
+exports.EXTENSION_PREFIX = process.env['EXTENSION_PREFIX'] || '';
+if (!exports.EXTENSION_PREFIX && !process.env['PORT_PREFIX']) {
+    throw new Error('CRITICAL: The extension does not define an own EXTENSION_PREFIX environment variable as part of the build, this is required to ensure that messages are not shared between extensions. Failure to do so will yield messages sent to multiple extensions.');
+}
+const PORT_PREFIX = `${exports.EXTENSION_PREFIX || 'unknown'}-${process.env['PORT_PREFIX'] || 'unknown'}`;
+exports.PORT_CONTENT = `${PORT_PREFIX}-content`;
+exports.PORT_EXTENSION = `${PORT_PREFIX}-extension`;
+exports.MESSAGE_ORIGIN_PAGE = `${PORT_PREFIX}-page`;
+exports.MESSAGE_ORIGIN_CONTENT = `${PORT_PREFIX}-content`;
+exports.ALLOWED_PATH = ['/', '/account/import-ledger', '/account/restore-json'];
+exports.PASSWORD_EXPIRY_MIN = 15;
+exports.PASSWORD_EXPIRY_MS = exports.PASSWORD_EXPIRY_MIN * 60 * 1000;
+exports.PHISHING_PAGE_REDIRECT = '/phishing-page-detected';