@polkadot/extension-base 0.53.1 → 0.55.1

package/cjs/background/RequestBytesSign.d.ts

@@ -0,0 +1,12 @@
+import type { KeyringPair } from '@polkadot/keyring/types';
+import type { TypeRegistry } from '@polkadot/types';
+import type { SignerPayloadRaw } from '@polkadot/types/types';
+import type { HexString } from '@polkadot/util/types';
+import type { RequestSign } from './types.js';
+export default class RequestBytesSign implements RequestSign {
+    readonly payload: SignerPayloadRaw;
+    constructor(payload: SignerPayloadRaw);
+    sign(_registry: TypeRegistry, pair: KeyringPair): {
+        signature: HexString;
+    };
+}

package/cjs/background/RequestExtrinsicSign.d.ts

@@ -0,0 +1,12 @@
+import type { KeyringPair } from '@polkadot/keyring/types';
+import type { TypeRegistry } from '@polkadot/types';
+import type { SignerPayloadJSON } from '@polkadot/types/types';
+import type { HexString } from '@polkadot/util/types';
+import type { RequestSign } from './types.js';
+export default class RequestExtrinsicSign implements RequestSign {
+    readonly payload: SignerPayloadJSON;
+    constructor(payload: SignerPayloadJSON);
+    sign(registry: TypeRegistry, pair: KeyringPair): {
+        signature: HexString;
+    };
+}

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

@@ -0,0 +1,49 @@
+/// <reference types="chrome" />
+import type { MessageTypes, RequestTypes, ResponseType } from '../types.js';
+import type State from './State.js';
+export default class Extension {
+    #private;
+    constructor(state: State);
+    private transformAccounts;
+    private accountsCreateExternal;
+    private accountsCreateHardware;
+    private accountsCreateSuri;
+    private accountsChangePassword;
+    private accountsEdit;
+    private accountsExport;
+    private accountsBatchExport;
+    private accountsForget;
+    private refreshAccountPasswordCache;
+    private accountsShow;
+    private accountsTie;
+    private accountsValidate;
+    private accountsSubscribe;
+    private authorizeApprove;
+    private authorizeUpdate;
+    private getAuthList;
+    private authorizeSubscribe;
+    private metadataApprove;
+    private metadataGet;
+    private metadataList;
+    private metadataReject;
+    private metadataSubscribe;
+    private jsonRestore;
+    private batchRestore;
+    private jsonGetAccountInfo;
+    private seedCreate;
+    private seedValidate;
+    private signingApprovePassword;
+    private signingApproveSignature;
+    private signingCancel;
+    private signingIsLocked;
+    private signingSubscribe;
+    private windowOpen;
+    private derive;
+    private derivationValidate;
+    private derivationCreate;
+    private removeAuthorization;
+    private rejectAuthRequest;
+    private updateCurrentTabs;
+    private getConnectedTabsUrl;
+    handle<TMessageType extends MessageTypes>(id: string, type: TMessageType, request: RequestTypes[TMessageType], port?: chrome.runtime.Port): Promise<ResponseType<TMessageType>>;
+}

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

@@ -0,0 +1,96 @@
+/// <reference types="chrome" />
+import type { MetadataDef, ProviderMeta } from '@polkadot/extension-inject/types';
+import type { JsonRpcResponse, ProviderInterface, ProviderInterfaceCallback } from '@polkadot/rpc-provider/types';
+import type { AccountJson, AuthorizeRequest, AuthUrlInfo, AuthUrls, MetadataRequest, RequestAuthorizeTab, RequestRpcSend, RequestRpcSubscribe, RequestRpcUnsubscribe, RequestSign, ResponseRpcListProviders, ResponseSigning, SigningRequest } from '../types.js';
+import { BehaviorSubject } from 'rxjs';
+interface Resolver<T> {
+    reject: (error: Error) => void;
+    resolve: (result: T) => void;
+}
+interface AuthRequest extends Resolver<AuthResponse> {
+    id: string;
+    idStr: string;
+    request: RequestAuthorizeTab;
+    url: string;
+}
+export type AuthorizedAccountsDiff = [url: string, authorizedAccounts: AuthUrlInfo['authorizedAccounts']][];
+interface MetaRequest extends Resolver<boolean> {
+    id: string;
+    request: MetadataDef;
+    url: string;
+}
+export interface AuthResponse {
+    result: boolean;
+    authorizedAccounts: string[];
+}
+type Providers = Record<string, {
+    meta: ProviderMeta;
+    start: () => ProviderInterface;
+}>;
+interface SignRequest extends Resolver<ResponseSigning> {
+    account: AccountJson;
+    id: string;
+    request: RequestSign;
+    url: string;
+}
+export declare enum NotificationOptions {
+    None = 0,
+    Normal = 1,
+    PopUp = 2
+}
+export default class State {
+    #private;
+    readonly authSubject: BehaviorSubject<AuthorizeRequest[]>;
+    readonly metaSubject: BehaviorSubject<MetadataRequest[]>;
+    readonly signSubject: BehaviorSubject<SigningRequest[]>;
+    readonly authUrlSubjects: Record<string, BehaviorSubject<AuthUrlInfo>>;
+    defaultAuthAccountSelection: string[];
+    constructor(providers?: Providers);
+    init(): Promise<void>;
+    get knownMetadata(): MetadataDef[];
+    get numAuthRequests(): number;
+    get numMetaRequests(): number;
+    get numSignRequests(): number;
+    get allAuthRequests(): AuthorizeRequest[];
+    get allMetaRequests(): MetadataRequest[];
+    get allSignRequests(): SigningRequest[];
+    get authUrls(): AuthUrls;
+    private popupClose;
+    private popupOpen;
+    private authComplete;
+    /**
+   * @deprecated This method is deprecated in favor of {@link updateCurrentTabs} and will be removed in a future release.
+   */
+    udateCurrentTabsUrl(urls: string[]): void;
+    updateCurrentTabsUrl(urls: string[]): void;
+    getConnectedTabsUrl(): string[];
+    deleteAuthRequest(requestId: string): void;
+    private saveCurrentAuthList;
+    private saveDefaultAuthAccounts;
+    updateDefaultAuthAccounts(newList: string[]): Promise<void>;
+    private metaComplete;
+    private signComplete;
+    stripUrl(url: string): string;
+    private updateIcon;
+    removeAuthorization(url: string): Promise<AuthUrls>;
+    private updateIconAuth;
+    private updateIconMeta;
+    private updateIconSign;
+    updateAuthorizedAccounts(authorizedAccountsDiff: AuthorizedAccountsDiff): Promise<void>;
+    authorizeUrl(url: string, request: RequestAuthorizeTab): Promise<AuthResponse>;
+    ensureUrlAuthorized(url: string): boolean;
+    injectMetadata(url: string, request: MetadataDef): Promise<boolean>;
+    getAuthRequest(id: string): AuthRequest;
+    getMetaRequest(id: string): MetaRequest;
+    getSignRequest(id: string): SignRequest;
+    rpcListProviders(): Promise<ResponseRpcListProviders>;
+    rpcSend(request: RequestRpcSend, port: chrome.runtime.Port): Promise<JsonRpcResponse<unknown>>;
+    rpcStartProvider(key: string, port: chrome.runtime.Port): Promise<ProviderMeta>;
+    rpcSubscribe({ method, params, type }: RequestRpcSubscribe, cb: ProviderInterfaceCallback, port: chrome.runtime.Port): Promise<number | string>;
+    rpcSubscribeConnected(_request: null, cb: ProviderInterfaceCallback, port: chrome.runtime.Port): void;
+    rpcUnsubscribe(request: RequestRpcUnsubscribe, port: chrome.runtime.Port): Promise<boolean>;
+    saveMetadata(meta: MetadataDef): Promise<void>;
+    setNotification(notification: string): boolean;
+    sign(url: string, request: RequestSign, account: AccountJson): Promise<ResponseSigning>;
+}
+export {};

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

@@ -0,0 +1,26 @@
+/// <reference types="chrome" />
+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/cjs/background/handlers/helpers.d.ts

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

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

@@ -0,0 +1,4 @@
+/// <reference types="chrome" />
+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/subscriptions.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="chrome" />
+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/index.d.ts

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

package/cjs/background/types.d.ts

@@ -0,0 +1,341 @@
+import type { InjectedAccount, InjectedMetadataKnown, MetadataDef, ProviderList, ProviderMeta } from '@polkadot/extension-inject/types';
+import type { KeyringPair, KeyringPair$Json, KeyringPair$Meta } from '@polkadot/keyring/types';
+import type { JsonRpcResponse } from '@polkadot/rpc-provider/types';
+import type { Registry, SignerPayloadJSON, SignerPayloadRaw } from '@polkadot/types/types';
+import type { KeyringPairs$Json } from '@polkadot/ui-keyring/types';
+import type { HexString } from '@polkadot/util/types';
+import type { KeypairType } from '@polkadot/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.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;
+}
+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/bundle.d.ts

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

package/cjs/defaults.d.ts

@@ -0,0 +1,9 @@
+export declare const EXTENSION_PREFIX: string;
+export declare const PORT_CONTENT: string;
+export declare const PORT_EXTENSION: string;
+export declare const MESSAGE_ORIGIN_PAGE: string;
+export declare const MESSAGE_ORIGIN_CONTENT: string;
+export declare const ALLOWED_PATH: readonly ["/", "/account/import-ledger", "/account/restore-json"];
+export declare const PASSWORD_EXPIRY_MIN = 15;
+export declare const PASSWORD_EXPIRY_MS: number;
+export declare const PHISHING_PAGE_REDIRECT = "/phishing-page-detected";

package/cjs/index.d.ts

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

package/cjs/packageDetect.d.ts

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

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

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

package/cjs/page/Accounts.d.ts

@@ -0,0 +1,7 @@
+import type { InjectedAccount, InjectedAccounts, Unsubcall } from '@polkadot/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/Injected.d.ts

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

@@ -0,0 +1,7 @@
+import type { InjectedMetadata, InjectedMetadataKnown, MetadataDef } from '@polkadot/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>;
+}