@novasamatech/product-sdk 0.5.0-6 → 0.5.0-8

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/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/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

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/product-sdk",
   "type": "module",
-  "version": "0.5.0-6",
+  "version": "0.5.0-8",
   "description": "Polkadot product SDK: integrate and run your product inside Polkadot browser.",
   "license": "Apache-2.0",
   "repository": {
@@ -29,7 +29,7 @@
     "@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.5.0-6"
+    "@novasamatech/host-api": "0.5.0-8"
   },
   "publishConfig": {
     "access": "public"