@pezkuwi/extension-base 0.62.8 → 0.62.12

package/page/PostMessageProvider.js

@@ -0,0 +1,132 @@
+import { EventEmitter } from 'eventemitter3';
+import { isUndefined, logger } from '@pezkuwi/util';
+const l = logger('PostMessageProvider');
+let sendRequest;
+/**
+ * @name PostMessageProvider
+ *
+ * @description Extension provider to be used by dapps
+ */
+export default 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 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 (isUndefined(this.#subscriptions[subscription])) {
+            l.debug(() => `Unable to find active subscription=${subscription}`);
+            return false;
+        }
+        delete this.#subscriptions[subscription];
+        return this.send(method, [id]);
+    }
+}

package/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/page/Signer.js

@@ -0,0 +1,26 @@
+let sendRequest;
+let nextId = 0;
+export default 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
+        };
+    }
+}

package/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/page/index.js

@@ -0,0 +1,45 @@
+import { MESSAGE_ORIGIN_PAGE } from '../defaults.js';
+import { getId } from '../utils/getId.js';
+import Injected from './Injected.js';
+const handlers = {};
+export function sendMessage(message, request, subscriber) {
+    return new Promise((resolve, reject) => {
+        const id = getId();
+        handlers[id] = { reject, resolve, subscriber };
+        const transportRequestMessage = {
+            id,
+            message,
+            origin: MESSAGE_ORIGIN_PAGE,
+            request: request || null
+        };
+        window.postMessage(transportRequestMessage, '*');
+    });
+}
+export async function enable(origin) {
+    await sendMessage('pub(authorize.tab)', { origin });
+    return new Injected(sendMessage);
+}
+export async function redirectIfPhishing() {
+    const res = await sendMessage('pub(phishing.redirectIfDenied)');
+    return res;
+}
+export 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/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/page/types.js

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

package/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/stores/Accounts.js

@@ -0,0 +1,17 @@
+import { EXTENSION_PREFIX } from '../defaults.js';
+import BaseStore from './Base.js';
+export default class AccountsStore extends BaseStore {
+    constructor() {
+        super(EXTENSION_PREFIX && EXTENSION_PREFIX !== 'polkadot{.js}'
+            ? `${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);
+    }
+}

package/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/stores/Base.js

@@ -0,0 +1,67 @@
+const lastError = (type) => {
+    const error = chrome.runtime.lastError;
+    if (error) {
+        console.error(`BaseStore.${type}:: runtime.lastError:`, error);
+    }
+};
+export default 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}`);
+        });
+    }
+}

package/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/stores/Metadata.js

@@ -0,0 +1,9 @@
+import { EXTENSION_PREFIX } from '../defaults.js';
+import BaseStore from './Base.js';
+export default class MetadataStore extends BaseStore {
+    constructor() {
+        super(EXTENSION_PREFIX && EXTENSION_PREFIX !== 'polkadot{.js}'
+            ? `${EXTENSION_PREFIX}metadata`
+            : 'metadata');
+    }
+}

package/{src/stores/index.ts → stores/index.d.ts}

@@ -1,5 +1,2 @@
-// Copyright 2019-2025 @pezkuwi/extension-base authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 export { default as AccountsStore } from './Accounts.js';
 export { default as MetadataStore } from './Metadata.js';

package/{build/stores → stores}/index.js

@@ -1,4 +1,2 @@
-// Copyright 2019-2025 @pezkuwi/extension-base authors & contributors
-// SPDX-License-Identifier: Apache-2.0
 export { default as AccountsStore } from './Accounts.js';
 export { default as MetadataStore } from './Metadata.js';

package/types.d.ts

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

package/types.js

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

package/utils/canDerive.d.ts

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

package/{build/utils → utils}/canDerive.js

@@ -1,5 +1,3 @@
-// Copyright 2019-2025 @pezkuwi/extension-base authors & contributors
-// SPDX-License-Identifier: Apache-2.0
 export function canDerive(type) {
     return !!type && ['ed25519', 'sr25519', 'ecdsa', 'ethereum'].includes(type);
 }

package/utils/getId.d.ts

@@ -0,0 +1 @@
+export declare function getId(): string;

package/utils/getId.js

@@ -0,0 +1,5 @@
+import { EXTENSION_PREFIX } from '../defaults.js';
+let counter = 0;
+export function getId() {
+    return `${EXTENSION_PREFIX}.${Date.now()}.${++counter}`;
+}

package/utils/index.d.ts

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

package/utils/index.js

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

package/utils/portUtils.d.ts

@@ -0,0 +1,13 @@
+import type { Message } from '@pezkuwi/extension-base/types';
+export declare function setupPort(portName: string, onMessageHandler: (data: Message['data']) => void, onDisconnectHandler: () => void): chrome.runtime.Port;
+export declare function wakeUpServiceWorker(): Promise<{
+    status: string;
+}>;
+export declare const wakeUpServiceWorkerWrapper: {
+    wakeUpServiceWorker: typeof wakeUpServiceWorker;
+};
+export declare function ensurePortConnection(portRef: chrome.runtime.Port | undefined, portConfig: {
+    portName: string;
+    onPortMessageHandler: (data: Message['data']) => void;
+    onPortDisconnectHandler: () => void;
+}): Promise<chrome.runtime.Port>;

package/utils/portUtils.js

@@ -0,0 +1,43 @@
+import { chrome } from '@pezkuwi/extension-inject/chrome';
+export function setupPort(portName, onMessageHandler, onDisconnectHandler) {
+    const port = chrome.runtime.connect({ name: portName });
+    port.onMessage.addListener(onMessageHandler);
+    port.onDisconnect.addListener(() => {
+        console.log(`Disconnected from ${portName}`);
+        onDisconnectHandler();
+    });
+    return port;
+}
+export async function wakeUpServiceWorker() {
+    return new Promise((resolve, reject) => {
+        chrome.runtime.sendMessage({ type: 'wakeup' }, (response) => {
+            if (chrome.runtime.lastError) {
+                reject(new Error(chrome.runtime.lastError.message));
+            }
+            else {
+                resolve(response);
+            }
+        });
+    });
+}
+export const wakeUpServiceWorkerWrapper = { wakeUpServiceWorker };
+export async function ensurePortConnection(portRef, portConfig) {
+    const maxAttempts = 5;
+    const delayMs = 1000;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        try {
+            const response = await wakeUpServiceWorkerWrapper.wakeUpServiceWorker();
+            if (response?.status === 'awake') {
+                if (!portRef) {
+                    return setupPort(portConfig.portName, portConfig.onPortMessageHandler, portConfig.onPortDisconnectHandler);
+                }
+                return portRef;
+            }
+        }
+        catch (error) {
+            console.error(`Attempt ${attempt + 1} failed: ${error.message}`);
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+    }
+    throw new Error('Failed to wake up the service worker and setup the port after multiple attempts');
+}

package/build/background/RequestBytesSign.js

@@ -1,15 +0,0 @@
-// Copyright 2019-2025 @pezkuwi/extension-base authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-import { u8aToHex, u8aWrapBytes } from '@pezkuwi/util';
-var RequestBytesSign = /** @class */ (function () {
-    function RequestBytesSign(payload) {
-        this.payload = payload;
-    }
-    RequestBytesSign.prototype.sign = function (_registry, pair) {
-        return {
-            signature: u8aToHex(pair.sign(u8aWrapBytes(this.payload.data)))
-        };
-    };
-    return RequestBytesSign;
-}());
-export default RequestBytesSign;

package/build/background/RequestExtrinsicSign.js

@@ -1,14 +0,0 @@
-// Copyright 2019-2025 @pezkuwi/extension-base authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-var RequestExtrinsicSign = /** @class */ (function () {
-    function RequestExtrinsicSign(payload) {
-        this.payload = payload;
-    }
-    RequestExtrinsicSign.prototype.sign = function (registry, pair) {
-        return registry
-            .createType('ExtrinsicPayload', this.payload, { version: this.payload.version })
-            .sign(pair);
-    };
-    return RequestExtrinsicSign;
-}());
-export default RequestExtrinsicSign;