@polkadot/extension-base 0.53.1 → 0.55.1

package/cjs/page/PostMessageProvider.d.ts

@@ -0,0 +1,63 @@
+import type { InjectedProvider, ProviderList, ProviderMeta } from '@polkadot/extension-inject/types';
+import type { ProviderInterfaceEmitCb, ProviderInterfaceEmitted } from '@polkadot/rpc-provider/types';
+import type { AnyFunction } from '@polkadot/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/Signer.d.ts

@@ -0,0 +1,8 @@
+import type { Signer as SignerInterface, SignerResult } from '@polkadot/api/types';
+import type { SignerPayloadJSON, SignerPayloadRaw } from '@polkadot/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/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/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/stores/Accounts.d.ts

@@ -0,0 +1,6 @@
+import type { KeyringJson, KeyringStore } from '@polkadot/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/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/Metadata.d.ts

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

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/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/utils/canDerive.d.ts

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

package/cjs/utils/getId.d.ts

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

package/cjs/utils/index.d.ts

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

package/cjs/utils/portUtils.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="chrome" />
+import type { Message } from '@polkadot/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>;