@pezkuwi/extension-base 0.62.10 → 0.62.13

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';

package/cjs/index.d.ts

@@ -0,0 +1 @@
+export * from './bundle.js';

package/cjs/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./bundle.js"), exports);

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/cjs/packageDetect.d.ts

@@ -0,0 +1 @@
+export {};

package/cjs/packageDetect.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const packageInfo_1 = require("@pezkuwi/extension-chains/cjs/packageInfo");
+const packageInfo_2 = require("@pezkuwi/extension-dapp/cjs/packageInfo");
+const packageInfo_3 = require("@pezkuwi/extension-inject/cjs/packageInfo");
+const util_1 = require("@pezkuwi/util");
+const packageInfo_js_1 = require("./packageInfo.js");
+(0, util_1.detectPackage)(packageInfo_js_1.packageInfo, null, [packageInfo_1.packageInfo, packageInfo_2.packageInfo, packageInfo_3.packageInfo]);

package/cjs/packageInfo.d.ts

@@ -0,0 +1,6 @@
+export declare const packageInfo: {
+    name: string;
+    path: string;
+    type: string;
+    version: string;
+};

package/cjs/packageInfo.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageInfo = void 0;
+exports.packageInfo = { name: '@pezkuwi/extension-base', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '0.62.12' };

package/cjs/page/Accounts.d.ts

@@ -0,0 +1,7 @@
+import type { InjectedAccount, InjectedAccounts, Unsubcall } from '@pezkuwi/extension-inject/types';
+import type { SendRequest } from './types.js';
+export default class Accounts implements InjectedAccounts {
+    constructor(_sendRequest: SendRequest);
+    get(anyType?: boolean): Promise<InjectedAccount[]>;
+    subscribe(cb: (accounts: InjectedAccount[]) => unknown): Unsubcall;
+}

package/cjs/page/Accounts.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+let sendRequest;
+class Accounts {
+    constructor(_sendRequest) {
+        sendRequest = _sendRequest;
+    }
+    get(anyType) {
+        return sendRequest('pub(accounts.list)', { anyType });
+    }
+    subscribe(cb) {
+        let id = null;
+        sendRequest('pub(accounts.subscribe)', null, cb)
+            .then((subId) => {
+            id = subId;
+        })
+            .catch(console.error);
+        return () => {
+            id && sendRequest('pub(accounts.unsubscribe)', { id })
+                .catch(console.error);
+        };
+    }
+}
+exports.default = Accounts;

package/cjs/page/Injected.d.ts

@@ -0,0 +1,13 @@
+import type { Injected } from '@pezkuwi/extension-inject/types';
+import type { SendRequest } from './types.js';
+import Accounts from './Accounts.js';
+import Metadata from './Metadata.js';
+import PostMessageProvider from './PostMessageProvider.js';
+import Signer from './Signer.js';
+export default class implements Injected {
+    readonly accounts: Accounts;
+    readonly metadata: Metadata;
+    readonly provider: PostMessageProvider;
+    readonly signer: Signer;
+    constructor(sendRequest: SendRequest);
+}

package/cjs/page/Injected.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const Accounts_js_1 = tslib_1.__importDefault(require("./Accounts.js"));
+const Metadata_js_1 = tslib_1.__importDefault(require("./Metadata.js"));
+const PostMessageProvider_js_1 = tslib_1.__importDefault(require("./PostMessageProvider.js"));
+const Signer_js_1 = tslib_1.__importDefault(require("./Signer.js"));
+class default_1 {
+    accounts;
+    metadata;
+    provider;
+    signer;
+    constructor(sendRequest) {
+        this.accounts = new Accounts_js_1.default(sendRequest);
+        this.metadata = new Metadata_js_1.default(sendRequest);
+        this.provider = new PostMessageProvider_js_1.default(sendRequest);
+        this.signer = new Signer_js_1.default(sendRequest);
+        setInterval(() => {
+            sendRequest('pub(ping)', null).catch(() => {
+                console.error('Extension unavailable, ping failed');
+            });
+        }, 5_000 + Math.floor(Math.random() * 5_000));
+    }
+}
+exports.default = default_1;

package/cjs/page/Metadata.d.ts

@@ -0,0 +1,7 @@
+import type { InjectedMetadata, InjectedMetadataKnown, MetadataDef } from '@pezkuwi/extension-inject/types';
+import type { SendRequest } from './types.js';
+export default class Metadata implements InjectedMetadata {
+    constructor(_sendRequest: SendRequest);
+    get(): Promise<InjectedMetadataKnown[]>;
+    provide(definition: MetadataDef): Promise<boolean>;
+}

package/cjs/page/Metadata.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+let sendRequest;
+class Metadata {
+    constructor(_sendRequest) {
+        sendRequest = _sendRequest;
+    }
+    get() {
+        return sendRequest('pub(metadata.list)');
+    }
+    provide(definition) {
+        return sendRequest('pub(metadata.provide)', definition);
+    }
+}
+exports.default = Metadata;

package/cjs/page/PostMessageProvider.d.ts

@@ -0,0 +1,63 @@
+import type { InjectedProvider, ProviderList, ProviderMeta } from '@pezkuwi/extension-inject/types';
+import type { ProviderInterfaceEmitCb, ProviderInterfaceEmitted } from '@pezkuwi/rpc-provider/types';
+import type { AnyFunction } from '@pezkuwi/types/types';
+import type { SendRequest } from './types.js';
+type CallbackHandler = (error?: null | Error, value?: unknown) => void;
+interface SubscriptionHandler {
+    callback: CallbackHandler;
+    type: string;
+}
+/**
+ * @name PostMessageProvider
+ *
+ * @description Extension provider to be used by dapps
+ */
+export default class PostMessageProvider implements InjectedProvider {
+    #private;
+    /**
+     * @param {function}  sendRequest  The function to be called to send requests to the node
+     * @param {function}  subscriptionNotificationHandler  Channel for receiving subscription messages
+     */
+    constructor(_sendRequest: SendRequest);
+    get isClonable(): boolean;
+    /**
+     * @description Returns a clone of the object
+     */
+    clone(): PostMessageProvider;
+    /**
+     * @description Manually disconnect from the connection, clearing autoconnect logic
+     */
+    connect(): Promise<void>;
+    /**
+     * @description Manually disconnect from the connection, clearing autoconnect logic
+     */
+    disconnect(): Promise<void>;
+    /**
+     * @summary `true` when this provider supports subscriptions
+     */
+    get hasSubscriptions(): boolean;
+    /**
+     * @summary Whether the node is connected or not.
+     * @return {boolean} true if connected
+     */
+    get isConnected(): boolean;
+    listProviders(): Promise<ProviderList>;
+    /**
+     * @summary Listens on events after having subscribed using the [[subscribe]] function.
+     * @param  {ProviderInterfaceEmitted} type Event
+     * @param  {ProviderInterfaceEmitCb}  sub  Callback
+     * @return unsubscribe function
+     */
+    on(type: ProviderInterfaceEmitted, sub: ProviderInterfaceEmitCb): () => void;
+    send(method: string, params: unknown[], _?: boolean, subscription?: SubscriptionHandler): Promise<any>;
+    /**
+     * @summary Spawn a provider on the extension background.
+     */
+    startProvider(key: string): Promise<ProviderMeta>;
+    subscribe(type: string, method: string, params: unknown[], callback: AnyFunction): Promise<number>;
+    /**
+     * @summary Allows unsubscribing to subscriptions made with [[subscribe]].
+     */
+    unsubscribe(type: string, method: string, id: number): Promise<boolean>;
+}
+export {};

package/cjs/page/PostMessageProvider.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const eventemitter3_1 = require("eventemitter3");
+const util_1 = require("@pezkuwi/util");
+const l = (0, util_1.logger)('PostMessageProvider');
+let sendRequest;
+/**
+ * @name PostMessageProvider
+ *
+ * @description Extension provider to be used by dapps
+ */
+class PostMessageProvider {
+    #eventemitter;
+    // Whether or not the actual extension background provider is connected
+    #isConnected = false;
+    // Subscription IDs are (historically) not guaranteed to be globally unique;
+    // only unique for a given subscription method; which is why we identify
+    // the subscriptions based on subscription id + type
+    #subscriptions = {}; // {[(type,subscriptionId)]: callback}
+    /**
+     * @param {function}  sendRequest  The function to be called to send requests to the node
+     * @param {function}  subscriptionNotificationHandler  Channel for receiving subscription messages
+     */
+    constructor(_sendRequest) {
+        this.#eventemitter = new eventemitter3_1.EventEmitter();
+        sendRequest = _sendRequest;
+    }
+    get isClonable() {
+        return !!true;
+    }
+    /**
+     * @description Returns a clone of the object
+     */
+    clone() {
+        return new PostMessageProvider(sendRequest);
+    }
+    /**
+     * @description Manually disconnect from the connection, clearing autoconnect logic
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async connect() {
+        // FIXME This should see if the extension's state's provider can disconnect
+        console.error('PostMessageProvider.disconnect() is not implemented.');
+    }
+    /**
+     * @description Manually disconnect from the connection, clearing autoconnect logic
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async disconnect() {
+        // FIXME This should see if the extension's state's provider can disconnect
+        console.error('PostMessageProvider.disconnect() is not implemented.');
+    }
+    /**
+     * @summary `true` when this provider supports subscriptions
+     */
+    get hasSubscriptions() {
+        // FIXME This should see if the extension's state's provider has subscriptions
+        return !!true;
+    }
+    /**
+     * @summary Whether the node is connected or not.
+     * @return {boolean} true if connected
+     */
+    get isConnected() {
+        return this.#isConnected;
+    }
+    listProviders() {
+        return sendRequest('pub(rpc.listProviders)', undefined);
+    }
+    /**
+     * @summary Listens on events after having subscribed using the [[subscribe]] function.
+     * @param  {ProviderInterfaceEmitted} type Event
+     * @param  {ProviderInterfaceEmitCb}  sub  Callback
+     * @return unsubscribe function
+     */
+    on(type, sub) {
+        this.#eventemitter.on(type, sub);
+        return () => {
+            this.#eventemitter.removeListener(type, sub);
+        };
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async send(method, params, _, subscription) {
+        if (subscription) {
+            const { callback, type } = subscription;
+            const id = await sendRequest('pub(rpc.subscribe)', { method, params, type }, (res) => {
+                subscription.callback(null, res);
+            });
+            this.#subscriptions[`${type}::${id}`] = callback;
+            return id;
+        }
+        return sendRequest('pub(rpc.send)', { method, params });
+    }
+    /**
+     * @summary Spawn a provider on the extension background.
+     */
+    async startProvider(key) {
+        // Disconnect from the previous provider
+        this.#isConnected = false;
+        this.#eventemitter.emit('disconnected');
+        const meta = await sendRequest('pub(rpc.startProvider)', key);
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        sendRequest('pub(rpc.subscribeConnected)', null, (connected) => {
+            this.#isConnected = connected;
+            if (connected) {
+                this.#eventemitter.emit('connected');
+            }
+            else {
+                this.#eventemitter.emit('disconnected');
+            }
+            return true;
+        });
+        return meta;
+    }
+    subscribe(type, method, params, callback) {
+        return this.send(method, params, false, { callback, type });
+    }
+    /**
+     * @summary Allows unsubscribing to subscriptions made with [[subscribe]].
+     */
+    async unsubscribe(type, method, id) {
+        const subscription = `${type}::${id}`;
+        // FIXME This now could happen with re-subscriptions. The issue is that with a re-sub
+        // the assigned id now does not match what the API user originally received. It has
+        // a slight complication in solving - since we cannot rely on the send id, but rather
+        // need to find the actual subscription id to map it
+        if ((0, util_1.isUndefined)(this.#subscriptions[subscription])) {
+            l.debug(() => `Unable to find active subscription=${subscription}`);
+            return false;
+        }
+        delete this.#subscriptions[subscription];
+        return this.send(method, [id]);
+    }
+}
+exports.default = PostMessageProvider;

package/cjs/page/Signer.d.ts

@@ -0,0 +1,8 @@
+import type { Signer as SignerInterface, SignerResult } from '@pezkuwi/api/types';
+import type { SignerPayloadJSON, SignerPayloadRaw } from '@pezkuwi/types/types';
+import type { SendRequest } from './types.js';
+export default class Signer implements SignerInterface {
+    constructor(_sendRequest: SendRequest);
+    signPayload(payload: SignerPayloadJSON): Promise<SignerResult>;
+    signRaw(payload: SignerPayloadRaw): Promise<SignerResult>;
+}

package/cjs/page/Signer.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+let sendRequest;
+let nextId = 0;
+class Signer {
+    constructor(_sendRequest) {
+        sendRequest = _sendRequest;
+    }
+    async signPayload(payload) {
+        const id = ++nextId;
+        const result = await sendRequest('pub(extrinsic.sign)', payload);
+        // we add an internal id (number) - should have a mapping from the
+        // extension id (string) -> internal id (number) if we wish to provide
+        // updated via the update functionality (noop at this point)
+        return {
+            ...result,
+            id
+        };
+    }
+    async signRaw(payload) {
+        const id = ++nextId;
+        const result = await sendRequest('pub(bytes.sign)', payload);
+        return {
+            ...result,
+            id
+        };
+    }
+}
+exports.default = Signer;

package/cjs/page/index.d.ts

@@ -0,0 +1,16 @@
+import type { MessageTypes, MessageTypesWithNoSubscriptions, MessageTypesWithNullRequest, MessageTypesWithSubscriptions, RequestTypes, ResponseTypes, SubscriptionMessageTypes, TransportResponseMessage } from '../background/types.js';
+import Injected from './Injected.js';
+export interface Handler {
+    resolve: (data?: any) => void;
+    reject: (error: Error) => void;
+    subscriber?: (data: any) => void;
+}
+export type Handlers = Record<string, Handler>;
+export declare function sendMessage<TMessageType extends MessageTypesWithNullRequest>(message: TMessageType): Promise<ResponseTypes[TMessageType]>;
+export declare function sendMessage<TMessageType extends MessageTypesWithNoSubscriptions>(message: TMessageType, request: RequestTypes[TMessageType]): Promise<ResponseTypes[TMessageType]>;
+export declare function sendMessage<TMessageType extends MessageTypesWithSubscriptions>(message: TMessageType, request: RequestTypes[TMessageType], subscriber: (data: SubscriptionMessageTypes[TMessageType]) => void): Promise<ResponseTypes[TMessageType]>;
+export declare function enable(origin: string): Promise<Injected>;
+export declare function redirectIfPhishing(): Promise<boolean>;
+export declare function handleResponse<TMessageType extends MessageTypes>(data: TransportResponseMessage<TMessageType> & {
+    subscription?: string;
+}): void;

package/cjs/page/index.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendMessage = sendMessage;
+exports.enable = enable;
+exports.redirectIfPhishing = redirectIfPhishing;
+exports.handleResponse = handleResponse;
+const tslib_1 = require("tslib");
+const defaults_js_1 = require("../defaults.js");
+const getId_js_1 = require("../utils/getId.js");
+const Injected_js_1 = tslib_1.__importDefault(require("./Injected.js"));
+const handlers = {};
+function sendMessage(message, request, subscriber) {
+    return new Promise((resolve, reject) => {
+        const id = (0, getId_js_1.getId)();
+        handlers[id] = { reject, resolve, subscriber };
+        const transportRequestMessage = {
+            id,
+            message,
+            origin: defaults_js_1.MESSAGE_ORIGIN_PAGE,
+            request: request || null
+        };
+        window.postMessage(transportRequestMessage, '*');
+    });
+}
+async function enable(origin) {
+    await sendMessage('pub(authorize.tab)', { origin });
+    return new Injected_js_1.default(sendMessage);
+}
+async function redirectIfPhishing() {
+    const res = await sendMessage('pub(phishing.redirectIfDenied)');
+    return res;
+}
+function handleResponse(data) {
+    const handler = handlers[data.id];
+    if (!handler) {
+        console.error(`Unknown response: ${JSON.stringify(data)}`);
+        return;
+    }
+    if (!handler.subscriber) {
+        delete handlers[data.id];
+    }
+    if (data.subscription) {
+        // eslint-disable-next-line @typescript-eslint/ban-types
+        handler.subscriber(data.subscription);
+    }
+    else if (data.error) {
+        handler.reject(new Error(data.error));
+    }
+    else {
+        handler.resolve(data.response);
+    }
+}

package/cjs/page/types.d.ts

@@ -0,0 +1,6 @@
+import type { MessageTypesWithNoSubscriptions, MessageTypesWithNullRequest, MessageTypesWithSubscriptions, RequestTypes, ResponseTypes, SubscriptionMessageTypes } from '../background/types.js';
+export interface SendRequest {
+    <TMessageType extends MessageTypesWithNullRequest>(message: TMessageType): Promise<ResponseTypes[TMessageType]>;
+    <TMessageType extends MessageTypesWithNoSubscriptions>(message: TMessageType, request: RequestTypes[TMessageType]): Promise<ResponseTypes[TMessageType]>;
+    <TMessageType extends MessageTypesWithSubscriptions>(message: TMessageType, request: RequestTypes[TMessageType], subscriber: (data: SubscriptionMessageTypes[TMessageType]) => void): Promise<ResponseTypes[TMessageType]>;
+}

package/cjs/page/types.js

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

package/cjs/stores/Accounts.d.ts

@@ -0,0 +1,6 @@
+import type { KeyringJson, KeyringStore } from '@pezkuwi/ui-keyring/types';
+import BaseStore from './Base.js';
+export default class AccountsStore extends BaseStore<KeyringJson> implements KeyringStore {
+    constructor();
+    set(key: string, value: KeyringJson, update?: () => void): Promise<void>;
+}

package/cjs/stores/Accounts.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const defaults_js_1 = require("../defaults.js");
+const Base_js_1 = tslib_1.__importDefault(require("./Base.js"));
+class AccountsStore extends Base_js_1.default {
+    constructor() {
+        super(defaults_js_1.EXTENSION_PREFIX && defaults_js_1.EXTENSION_PREFIX !== 'polkadot{.js}'
+            ? `${defaults_js_1.EXTENSION_PREFIX}accounts`
+            : null);
+    }
+    async set(key, value, update) {
+        // shortcut, don't save testing accounts in extension storage
+        if (key.startsWith('account:') && value.meta && value.meta.isTesting) {
+            update && update();
+            return;
+        }
+        await super.set(key, value, update);
+    }
+}
+exports.default = AccountsStore;

package/cjs/stores/Base.d.ts

@@ -0,0 +1,9 @@
+export default abstract class BaseStore<T> {
+    #private;
+    constructor(prefix: string | null);
+    all(update: (key: string, value: T) => void): Promise<void>;
+    allMap(update: (value: Record<string, T>) => Promise<void>): Promise<void>;
+    get(key: string, update: (value: T) => void): Promise<void>;
+    remove(key: string, update?: () => void): Promise<void>;
+    set(key: string, value: T, update?: () => void): Promise<void>;
+}

package/cjs/stores/Base.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lastError = (type) => {
+    const error = chrome.runtime.lastError;
+    if (error) {
+        console.error(`BaseStore.${type}:: runtime.lastError:`, error);
+    }
+};
+class BaseStore {
+    #prefix;
+    constructor(prefix) {
+        this.#prefix = prefix ? `${prefix}:` : '';
+    }
+    async all(update) {
+        await this.allMap(async (map) => {
+            const entries = Object.entries(map);
+            for (const [key, value] of entries) {
+                // eslint-disable-next-line @typescript-eslint/await-thenable
+                await update(key, value);
+            }
+        });
+    }
+    async allMap(update) {
+        await chrome.storage.local.get(null).then(async (result) => {
+            lastError('all');
+            const entries = Object.entries(result);
+            const map = {};
+            for (let i = 0, count = entries.length; i < count; i++) {
+                const [key, value] = entries[i];
+                if (key.startsWith(this.#prefix)) {
+                    map[key.replace(this.#prefix, '')] = value;
+                }
+            }
+            await update(map);
+        }).catch(({ message }) => {
+            console.error(`BaseStore error within allMap: ${message}`);
+        });
+    }
+    async get(key, update) {
+        const prefixedKey = `${this.#prefix}${key}`;
+        await chrome.storage.local.get([prefixedKey]).then(async (result) => {
+            lastError('get');
+            // eslint-disable-next-line @typescript-eslint/await-thenable
+            await update(result[prefixedKey]);
+        }).catch(({ message }) => {
+            console.error(`BaseStore error within get: ${message}`);
+        });
+    }
+    async remove(key, update) {
+        const prefixedKey = `${this.#prefix}${key}`;
+        await chrome.storage.local.remove(prefixedKey).then(async () => {
+            lastError('remove');
+            // eslint-disable-next-line @typescript-eslint/await-thenable
+            update && await update();
+        }).catch(({ message }) => {
+            console.error(`BaseStore error within remove: ${message}`);
+        });
+    }
+    async set(key, value, update) {
+        const prefixedKey = `${this.#prefix}${key}`;
+        await chrome.storage.local.set({ [prefixedKey]: value }).then(async () => {
+            lastError('set');
+            // eslint-disable-next-line @typescript-eslint/await-thenable
+            update && await update();
+        }).catch(({ message }) => {
+            console.error(`BaseStore error within set: ${message}`);
+        });
+    }
+}
+exports.default = BaseStore;

package/cjs/stores/Metadata.d.ts

@@ -0,0 +1,5 @@
+import type { MetadataDef } from '@pezkuwi/extension-inject/types';
+import BaseStore from './Base.js';
+export default class MetadataStore extends BaseStore<MetadataDef> {
+    constructor();
+}

package/cjs/stores/Metadata.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const defaults_js_1 = require("../defaults.js");
+const Base_js_1 = tslib_1.__importDefault(require("./Base.js"));
+class MetadataStore extends Base_js_1.default {
+    constructor() {
+        super(defaults_js_1.EXTENSION_PREFIX && defaults_js_1.EXTENSION_PREFIX !== 'polkadot{.js}'
+            ? `${defaults_js_1.EXTENSION_PREFIX}metadata`
+            : 'metadata');
+    }
+}
+exports.default = MetadataStore;

package/cjs/stores/index.d.ts

@@ -0,0 +1,2 @@
+export { default as AccountsStore } from './Accounts.js';
+export { default as MetadataStore } from './Metadata.js';

package/cjs/stores/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataStore = exports.AccountsStore = void 0;
+const tslib_1 = require("tslib");
+var Accounts_js_1 = require("./Accounts.js");
+Object.defineProperty(exports, "AccountsStore", { enumerable: true, get: function () { return tslib_1.__importDefault(Accounts_js_1).default; } });
+var Metadata_js_1 = require("./Metadata.js");
+Object.defineProperty(exports, "MetadataStore", { enumerable: true, get: function () { return tslib_1.__importDefault(Metadata_js_1).default; } });

package/cjs/types.d.ts

@@ -0,0 +1,9 @@
+export interface Message extends MessageEvent {
+    data: {
+        error?: string;
+        id: string;
+        origin: string;
+        response?: string;
+        subscription?: string;
+    };
+}

package/cjs/types.js

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

package/cjs/utils/canDerive.d.ts

@@ -0,0 +1,2 @@
+import type { KeypairType } from '@pezkuwi/util-crypto/types';
+export declare function canDerive(type?: KeypairType): boolean;

package/cjs/utils/canDerive.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canDerive = canDerive;
+function canDerive(type) {
+    return !!type && ['ed25519', 'sr25519', 'ecdsa', 'ethereum'].includes(type);
+}