@novasamatech/product-sdk 0.4.0

package/README.md

@@ -0,0 +1,82 @@
+# @novasamatech/product-sdk
+
+Easy way to embed Polkadot host functionality into your dapp.
+
+## Overview
+
+Spektr SDK provides a set of tools to integrate your application with Spektr dapp browser.
+Core features:
+- Generic account provider similar to [polkadot-js extension](https://polkadot.js.org/extension/).
+- Redirect [PAPI](https://papi.how/) requests to host application
+- Receive additional information from host application - supported chains, theme, etc.
+
+## Installation
+
+```shell
+npm install @novasamatech/product-sdk --save -E
+```
+
+## Usage
+
+### Injecting account provider into `injectedWeb3` interface
+
+Spektr SDK can provide account information and signers with same interface as any other polkadot compatible wallet.
+
+```ts
+import { injectSpektrExtension, SpektrExtensionName } from '@novasamatech/product-sdk';
+import { connectInjectedExtension, type InjectedPolkadotAccount } from '@polkadot-api/pjs-signer';
+
+async function getSpektrExtension() {
+  const ready = await injectSpektrExtension();
+
+  if (ready) {
+    return connectInjectedExtension(SpektrExtensionName)
+  }
+
+  return null;
+}
+
+async function getAccounts(): Promise<InjectedPolkadotAccount[]> {
+  const extension = await getSpektrExtension();
+
+  if (extension) {
+    return extension.getAccounts()
+  }
+
+  // fallback to other providers
+  return [];
+}
+```
+
+### Redirecting PAPI requests to host application
+
+You can wrap your PAPI provider with spektr provider to support redirecting requests to host application.
+
+```diff
+import { createClient, type PolkadotClient } from 'polkadot-api';
+import { getWsProvider } from 'polkadot-api/ws-provider';
+import { createSpektrPapiProvider, WellKnownChain } from '@novasamatech/product-sdk';
+
+function createPapiClient(): PolkadotClient {
+  const polkadotEndpoint = 'wss://...';
+
+-  const provider = getWsProvider(polkadotEndpoint);
++  const provider = createSpektrPapiProvider({
++    chainId: WellKnownChain.polkadotRelay,
++    fallback: getWsProvider(polkadotEndpoint),
++  });
+
+  return createClient(provider);
+}
+```
+
+### Subscribing metadata and statuses
+
+```ts
+import { spektrMetaProvider } from '@novasamatech/product-sdk';
+
+const unsubscribe = spektrMetaProvider.subscribeConnectionStatus((status) => {
+  console.log('connection status changed', status);
+});
+```
+

package/dist/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const Version: string;
+export declare const SpektrExtensionName = "spektr";
+export declare const WellKnownChain: {
+    readonly polkadotRelay: "0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3";
+    readonly polkadotAssetHub: "0x68d56f15f85d3136970ec16946040bc1752654e906147f7e43e9d539d7c3de2f";
+    readonly kusamaRelay: "0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe";
+    readonly kusamaAssetHub: "0x48239ef607d7928874027a43a67689209727dfb3d3dc5e5b03a39bdc2eda771a";
+    readonly westendRelay: "0xe143f23803ac50e8f6f8e62695d1ce9e4e1d68aa36c1cd2cfd15340213f3423e";
+    readonly westendAssetHub: "0x67f9723393ef76214df0118c34bbbd3dbebc8ed46a10973a8c969d48fe7598c9";
+    readonly rococo: "0x6408de7737c59c238890533af25896a2c20608d8b380bb01029acb392781063e";
+};

package/dist/constants.js

@@ -0,0 +1,12 @@
+import pkg from '../package.json';
+export const Version = pkg.version;
+export const SpektrExtensionName = 'spektr';
+export const WellKnownChain = {
+    polkadotRelay: '0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3',
+    polkadotAssetHub: '0x68d56f15f85d3136970ec16946040bc1752654e906147f7e43e9d539d7c3de2f',
+    kusamaRelay: '0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe',
+    kusamaAssetHub: '0x48239ef607d7928874027a43a67689209727dfb3d3dc5e5b03a39bdc2eda771a',
+    westendRelay: '0xe143f23803ac50e8f6f8e62695d1ce9e4e1d68aa36c1cd2cfd15340213f3423e',
+    westendAssetHub: '0x67f9723393ef76214df0118c34bbbd3dbebc8ed46a10973a8c969d48fe7598c9',
+    rococo: '0x6408de7737c59c238890533af25896a2c20608d8b380bb01029acb392781063e',
+};

package/dist/createSpektrMetaProvider.d.ts

@@ -0,0 +1,7 @@
+import type { ConnectionStatus, Transport } from '@novasamatech/host-api';
+export declare function createSpektrMetaProvider(transport?: Transport): {
+    subscribeConnectionStatus(callback: (connectionStatus: ConnectionStatus) => void): VoidFunction;
+};
+export declare const spektrMetaProvider: {
+    subscribeConnectionStatus(callback: (connectionStatus: ConnectionStatus) => void): VoidFunction;
+};

package/dist/createSpektrMetaProvider.js

@@ -0,0 +1,21 @@
+import { defaultTransport } from './defaultTransport';
+export function createSpektrMetaProvider(transport = defaultTransport) {
+    if (transport.isCorrectEnvironment() && typeof window !== 'undefined') {
+        const getUrl = () => {
+            return window.location.pathname + window.location.hash + window.location.search;
+        };
+        window.addEventListener('hashchange', () => {
+            transport.postMessage('_', { tag: 'locationChangedV1', value: getUrl() });
+        });
+        window.addEventListener('popstate', () => {
+            transport.postMessage('_', { tag: 'locationChangedV1', value: getUrl() });
+        });
+        transport.postMessage('_', { tag: 'locationChangedV1', value: getUrl() });
+    }
+    return {
+        subscribeConnectionStatus(callback) {
+            return transport.onConnectionStatusChange(callback);
+        },
+    };
+}
+export const spektrMetaProvider = createSpektrMetaProvider();

package/dist/createSpektrPapiProvider.d.ts

@@ -0,0 +1,11 @@
+import type { HexString, Transport } from '@novasamatech/host-api';
+import type { JsonRpcProvider } from '@polkadot-api/json-rpc-provider';
+type Params = {
+    chainId: HexString;
+    fallback: JsonRpcProvider;
+};
+type InternalParams = {
+    transport?: Transport;
+};
+export declare function createSpektrPapiProvider({ chainId, fallback }: Params, internal?: InternalParams): JsonRpcProvider;
+export {};

package/dist/createSpektrPapiProvider.js

@@ -0,0 +1,43 @@
+import { unwrapResponseOrThrow } from '@novasamatech/host-api';
+import { getSyncProvider } from '@polkadot-api/json-rpc-provider-proxy';
+import { defaultTransport } from './defaultTransport';
+export function createSpektrPapiProvider({ chainId, fallback }, internal) {
+    const transport = internal?.transport ?? defaultTransport;
+    if (!transport.isCorrectEnvironment())
+        return fallback;
+    const spektrProvider = onMessage => {
+        const unsubscribe = transport.subscribe('papiProviderReceiveMessageV1', (_, payload) => {
+            const unwrapped = unwrapResponseOrThrow(payload);
+            if (unwrapped.chainId === chainId) {
+                onMessage(unwrapped.message);
+            }
+        });
+        return {
+            send(message) {
+                transport.postMessage('_', { tag: 'papiProviderSendMessageV1', value: { chainId, message } });
+            },
+            disconnect() {
+                unsubscribe();
+            },
+        };
+    };
+    function checkIfReady() {
+        return transport.isReady().then(ready => {
+            if (!ready)
+                return false;
+            return transport
+                .request({ tag: 'supportFeatureRequestV1', value: { tag: 'chain', value: { chainId } } }, 'supportFeatureResponseV1')
+                .then(payload => {
+                const result = unwrapResponseOrThrow(payload);
+                if (result.tag === 'chain' && result.value.chainId === chainId) {
+                    return result.value.result;
+                }
+            })
+                .catch(e => {
+                transport.provider.logger.error('Error checking chain support', e);
+                return false;
+            });
+        });
+    }
+    return getSyncProvider(() => checkIfReady().then(ready => (ready ? spektrProvider : fallback)));
+}

package/dist/createTransport.d.ts

@@ -0,0 +1,21 @@
+import { type MessagePayloadSchema, type MessageType, type PickMessagePayload } from '@novasamatech/host-api';
+export type Provider = {
+    send(message: Uint8Array): void;
+    on(callback: (message: Uint8Array) => void): () => void;
+};
+export declare const defaultProvider: Provider;
+export type Transport = NonNullable<ReturnType<typeof createTransport>>;
+export declare function createTransport(provider: Provider): {
+    isSpektrReady(): Promise<boolean>;
+    subscribeAny(callback: (id: string, payload: MessagePayloadSchema) => void): () => void;
+    subscribe<const Type extends MessageType>(type: Type, callback: (id: string, payload: PickMessagePayload<Type>) => void): () => void;
+    send(id: string, payload: MessagePayloadSchema): string;
+    request(payload: MessagePayloadSchema): Promise<MessagePayloadSchema>;
+} | null;
+export declare const defaultTransport: {
+    isSpektrReady(): Promise<boolean>;
+    subscribeAny(callback: (id: string, payload: MessagePayloadSchema) => void): () => void;
+    subscribe<const Type extends MessageType>(type: Type, callback: (id: string, payload: PickMessagePayload<Type>) => void): () => void;
+    send(id: string, payload: MessagePayloadSchema): string;
+    request(payload: MessagePayloadSchema): Promise<MessagePayloadSchema>;
+} | null;

package/dist/createTransport.js

@@ -0,0 +1,111 @@
+import { HANDSHAKE_INTERVAL, isValidMessage, promiseWithResolvers } from '@novasamatech/product-sdk-shared';
+import { messageEncoder, } from '@novasamatech/host-api';
+import { nanoid } from 'nanoid';
+import { getParentWindow, inIframe } from './utils';
+export const defaultProvider = {
+    send(message) {
+        getParentWindow().postMessage(message, '*', [message.buffer]);
+    },
+    on(callback) {
+        const handle = (event) => {
+            if (!isValidMessage(event, getParentWindow(), window))
+                return;
+            callback(event.data);
+        };
+        window.addEventListener('message', handle);
+        return () => {
+            window.removeEventListener('message', handle);
+        };
+    },
+};
+export function createTransport(provider) {
+    if (!inIframe()) {
+        return null;
+    }
+    const readyAbortController = new AbortController();
+    let connected = null;
+    const api = {
+        isSpektrReady() {
+            if (connected !== null) {
+                return Promise.resolve(connected);
+            }
+            let resolved = false;
+            const request = new Promise(resolve => {
+                const interval = setInterval(() => {
+                    if (readyAbortController.signal.aborted) {
+                        clearInterval(interval);
+                        resolve(false);
+                        return;
+                    }
+                    const id = nanoid();
+                    const encoded = messageEncoder.enc({ id, payload: { tag: 'handshakeRequestV1', value: undefined } });
+                    const unsubscribe = api.subscribe('handshakeResponseV1', receivedId => {
+                        if (receivedId !== id)
+                            return;
+                        clearInterval(interval);
+                        unsubscribe();
+                        resolved = true;
+                        resolve(true);
+                    });
+                    provider.send(encoded);
+                }, HANDSHAKE_INTERVAL);
+            });
+            return Promise.race([
+                request,
+                new Promise(resolve => {
+                    setTimeout(() => {
+                        if (!resolved) {
+                            readyAbortController.abort();
+                            resolve(false);
+                        }
+                    }, 1_000);
+                }).then(result => {
+                    connected = result;
+                    return result;
+                }),
+            ]);
+        },
+        subscribeAny(callback) {
+            return provider.on(message => {
+                let result;
+                try {
+                    result = messageEncoder.dec(message);
+                }
+                catch {
+                    return;
+                }
+                callback(result.id, result.payload);
+            });
+        },
+        subscribe(type, callback) {
+            return api.subscribeAny((id, message) => {
+                if (message.tag == type) {
+                    callback(id, message);
+                }
+            });
+        },
+        send(id, payload) {
+            const encoded = messageEncoder.enc({ id, payload });
+            provider.send(encoded);
+            return id;
+        },
+        async request(payload) {
+            const ready = await api.isSpektrReady();
+            if (!ready) {
+                throw new Error('Spektr is not ready');
+            }
+            const id = nanoid();
+            const { resolve, promise } = promiseWithResolvers();
+            const unsubscribe = api.subscribeAny((receivedId, message) => {
+                if (receivedId === id) {
+                    unsubscribe();
+                    resolve(message);
+                }
+            });
+            api.send(id, payload);
+            return promise;
+        },
+    };
+    return api;
+}
+export const defaultTransport = createTransport(defaultProvider);

package/dist/defaultTransport.d.ts

@@ -0,0 +1,3 @@
+import type { TransportProvider } from '@novasamatech/host-api';
+export declare const defaultProvider: TransportProvider;
+export declare const defaultTransport: import("@novasamatech/host-api").Transport;

package/dist/defaultTransport.js

@@ -0,0 +1,57 @@
+import { createDefaultLogger, createTransport } from '@novasamatech/host-api';
+function getParentWindow() {
+    if (window.top) {
+        return window.top;
+    }
+    throw new Error('No parent window found');
+}
+function isIframe() {
+    try {
+        return window !== window.top;
+    }
+    catch {
+        return false;
+    }
+}
+function isValidMessage(event, sourceEnv, currentEnv) {
+    return (event.source !== currentEnv &&
+        event.source === sourceEnv &&
+        event.data &&
+        event.data.constructor.name === 'Uint8Array');
+}
+function createDefaultSdkProvider() {
+    const subscribers = new Set();
+    const handleMessage = (event) => {
+        if (!isValidMessage(event, getParentWindow(), window))
+            return;
+        for (const subscriber of subscribers) {
+            subscriber(event.data);
+        }
+    };
+    if (isIframe()) {
+        window.addEventListener('message', handleMessage);
+    }
+    return {
+        logger: createDefaultLogger(),
+        isCorrectEnvironment() {
+            return isIframe();
+        },
+        postMessage(message) {
+            getParentWindow().postMessage(message, '*', [message.buffer]);
+        },
+        subscribe(callback) {
+            subscribers.add(callback);
+            return () => {
+                subscribers.delete(callback);
+            };
+        },
+        dispose() {
+            subscribers.clear();
+            if (isIframe()) {
+                window.removeEventListener('message', handleMessage);
+            }
+        },
+    };
+}
+export const defaultProvider = createDefaultSdkProvider();
+export const defaultTransport = createTransport(defaultProvider, { handshakeTimeout: 1_000 });

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { SpektrExtensionName, WellKnownChain } from './constants';
+export { defaultProvider, defaultTransport } from './defaultTransport';
+export { spektrMetaProvider } from './createSpektrMetaProvider';
+export { createSpektrMetaProvider } from './createSpektrMetaProvider';
+export { createExtensionEnableFactory, injectSpektrExtension } from './injectSpektrExtension';
+export { createSpektrPapiProvider } from './createSpektrPapiProvider';

package/dist/index.js

@@ -0,0 +1,6 @@
+export { SpektrExtensionName, WellKnownChain } from './constants';
+export { defaultProvider, defaultTransport } from './defaultTransport';
+export { spektrMetaProvider } from './createSpektrMetaProvider';
+export { createSpektrMetaProvider } from './createSpektrMetaProvider';
+export { createExtensionEnableFactory, injectSpektrExtension } from './injectSpektrExtension';
+export { createSpektrPapiProvider } from './createSpektrPapiProvider';

package/dist/inject.d.ts

@@ -0,0 +1,2 @@
+import { type Provider } from './createTransport';
+export declare function inject(provider?: Provider): Promise<boolean>;

package/dist/inject.js

@@ -0,0 +1,60 @@
+import { injectExtension } from '@polkadot/extension-inject';
+import { unwrapResponseOrThrow } from '@spektr/sdk-transport';
+import { SpektrExtensionName, Version } from './constants';
+import { createTransport, defaultProvider } from './createTransport';
+function injectPolkadotExtension(transport) {
+    async function enable() {
+        return {
+            accounts: {
+                get() {
+                    return transport.request({ tag: 'getAccountsRequestV1', value: undefined }).then(e => {
+                        if (e.tag === 'getAccountsResponseV1') {
+                            return unwrapResponseOrThrow(e.value);
+                        }
+                        throw new Error(`Invalid response, got ${e.tag} message`);
+                    });
+                },
+                subscribe(callback) {
+                    return transport.subscribe('getAccountsResponseV1', (_, message) => {
+                        try {
+                            const accounts = unwrapResponseOrThrow(message.value);
+                            callback(accounts);
+                        }
+                        catch {
+                            console.error('Invalid account response, got', message.value.value);
+                        }
+                    });
+                },
+            },
+            signer: {
+                signRaw(raw) {
+                    return transport.request({ tag: 'signRawRequestV1', value: raw }).then(response => {
+                        if (response.tag === 'signPayloadResponseV1') {
+                            return unwrapResponseOrThrow(response.value);
+                        }
+                        throw new Error(`Invalid response, got ${response.tag} message`);
+                    });
+                },
+                signPayload(payload) {
+                    return transport.request({ tag: 'signPayloadRequestV1', value: payload }).then(response => {
+                        if (response.tag === 'signPayloadResponseV1') {
+                            return unwrapResponseOrThrow(response.value);
+                        }
+                        throw new Error(`Invalid response, got ${response.tag} message`);
+                    });
+                },
+            },
+        };
+    }
+    injectExtension(enable, { name: SpektrExtensionName, version: Version });
+}
+export async function inject(provider = defaultProvider) {
+    const transport = createTransport(provider);
+    if (!transport)
+        return false;
+    const ready = await transport.isSpektrReady();
+    if (!ready)
+        return false;
+    injectPolkadotExtension(transport);
+    return true;
+}

package/dist/injectSpektrExtension.d.ts

@@ -0,0 +1,24 @@
+import type { HexString, Transport, TxPayloadV1 } from '@novasamatech/host-api';
+import type { InjectedAccounts } from '@polkadot/extension-inject/types';
+import type { SignerPayloadJSON, SignerPayloadRaw, SignerResult } from '@polkadot/types/types/extrinsic';
+interface Signer {
+    /**
+     * @description signs an extrinsic payload from a serialized form
+     */
+    signPayload?: (payload: SignerPayloadJSON) => Promise<SignerResult>;
+    /**
+     * @description signs a raw payload, only the bytes data as supplied
+     */
+    signRaw?: (raw: SignerPayloadRaw) => Promise<SignerResult>;
+    /**
+     * @description signs a transaction according to https://github.com/polkadot-js/api/issues/6213
+     */
+    createTransaction?: (payload: TxPayloadV1) => Promise<HexString>;
+}
+interface Injected {
+    accounts: InjectedAccounts;
+    signer: Signer;
+}
+export declare function createExtensionEnableFactory(transport: Transport): Promise<(() => Promise<Injected>) | null>;
+export declare function injectSpektrExtension(transport?: Transport | null): Promise<boolean>;
+export {};

package/dist/injectSpektrExtension.js

@@ -0,0 +1,72 @@
+import { unwrapResponseOrThrow } from '@novasamatech/host-api';
+import { injectExtension } from '@polkadot/extension-inject';
+import { SpektrExtensionName, Version } from './constants';
+import { defaultTransport } from './defaultTransport';
+export async function createExtensionEnableFactory(transport) {
+    const ready = await transport.isReady();
+    if (!ready)
+        return null;
+    async function enable() {
+        return {
+            accounts: {
+                get() {
+                    return transport
+                        .request({ tag: 'getAccountsRequestV1', value: undefined }, 'getAccountsResponseV1')
+                        .then(unwrapResponseOrThrow);
+                },
+                subscribe(callback) {
+                    const unsubscribe = transport.subscribe('getAccountsResponseV1', (_, payload) => {
+                        try {
+                            const accounts = unwrapResponseOrThrow(payload);
+                            callback(accounts);
+                        }
+                        catch {
+                            transport.provider.logger.error('Failed response on account subscription', payload.value);
+                        }
+                    });
+                    transport.postMessage('_', { tag: 'accountSubscriptionV1', value: undefined });
+                    return () => {
+                        transport.postMessage('_', { tag: 'accountUnsubscriptionV1', value: undefined });
+                        unsubscribe();
+                    };
+                },
+            },
+            signer: {
+                signRaw(raw) {
+                    return transport
+                        .request({ tag: 'signRawRequestV1', value: raw }, 'signResponseV1')
+                        .then(unwrapResponseOrThrow);
+                },
+                signPayload(payload) {
+                    return transport
+                        .request({ tag: 'signPayloadRequestV1', value: payload }, 'signResponseV1')
+                        .then(unwrapResponseOrThrow);
+                },
+                createTransaction(payload) {
+                    return transport
+                        .request({ tag: 'createTransactionRequestV1', value: payload }, 'createTransactionResponseV1')
+                        .then(unwrapResponseOrThrow);
+                },
+            },
+        };
+    }
+    return enable;
+}
+export async function injectSpektrExtension(transport = defaultTransport) {
+    if (!transport)
+        return false;
+    try {
+        const enable = await createExtensionEnableFactory(transport);
+        if (enable) {
+            injectExtension(enable, { name: SpektrExtensionName, version: Version });
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    catch (e) {
+        transport.provider.logger.error('Error injecting extension', e);
+        return false;
+    }
+}

package/dist/transport.d.ts

@@ -0,0 +1,3 @@
+import type { TransportProvider } from '@novasamatech/host-api';
+export declare const defaultProvider: TransportProvider;
+export declare const defaultTransport: import("@novasamatech/host-api").Transport;

package/dist/transport.js

@@ -0,0 +1,51 @@
+import { isValidMessage } from '@novasamatech/product-sdk-shared';
+import { createTransport } from '@novasamatech/host-api';
+function getParentWindow() {
+    if (window.top) {
+        return window.top;
+    }
+    throw new Error('No parent window found');
+}
+function isIframe() {
+    try {
+        return window !== window.top;
+    }
+    catch {
+        return false;
+    }
+}
+function createDefaultSdkProvider() {
+    const subscribers = new Set();
+    const handleMessage = (event) => {
+        if (!isValidMessage(event, getParentWindow(), window))
+            return;
+        for (const subscriber of subscribers) {
+            subscriber(event.data);
+        }
+    };
+    if (isIframe()) {
+        window.addEventListener('message', handleMessage);
+    }
+    return {
+        isCorrectEnvironment() {
+            return isIframe();
+        },
+        postMessage(message) {
+            getParentWindow().postMessage(message, '*', [message.buffer]);
+        },
+        subscribe(callback) {
+            subscribers.add(callback);
+            return () => {
+                subscribers.delete(callback);
+            };
+        },
+        dispose() {
+            subscribers.clear();
+            if (isIframe()) {
+                window.removeEventListener('message', handleMessage);
+            }
+        },
+    };
+}
+export const defaultProvider = createDefaultSdkProvider();
+export const defaultTransport = createTransport(defaultProvider, { handshakeTimeout: 1_000 });

package/dist/types.d.ts

@@ -0,0 +1,8 @@
+import type { Injected } from '@polkadot/extension-inject/types';
+export interface InjectedWindowProvider {
+    enable: () => Promise<Injected>;
+    version: string;
+}
+export interface InjectedWindow {
+    injectedWeb3: Record<string, InjectedWindowProvider>;
+}

package/dist/types.js

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

package/dist/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function inIframe(): boolean;
+export declare function getParentWindow(): Window;

package/dist/utils.js

@@ -0,0 +1,14 @@
+export function inIframe() {
+    try {
+        return window !== window.top;
+    }
+    catch {
+        return false;
+    }
+}
+export function getParentWindow() {
+    if (window.top) {
+        return window.top;
+    }
+    throw new Error('No parent window found');
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@novasamatech/product-sdk",
+  "type": "module",
+  "version": "0.4.0",
+  "description": "Polkadot product SDK: integrate and run your product inside Polkadot browser.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/novasamatech/spektr-sdk.git"
+  },
+  "keywords": [
+    "polkadot",
+    "spektr",
+    "dapp"
+  ],
+  "main": "dist/index.js",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@polkadot/extension-inject": "0.62.5",
+    "@polkadot-api/json-rpc-provider": "0.0.4",
+    "@polkadot-api/json-rpc-provider-proxy": "0.2.7",
+    "@novasamatech/host-api": "0.4.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}