@novasamatech/product-sdk 0.5.0-18 → 0.5.0-19

package/dist/injectSpektrExtension.js

@@ -1,43 +1,69 @@
-import { unwrapResultOrThrow } from '@novasamatech/host-api';
+import { assertEnumVariant, createHostApi, enumValue, fromHex, toHex } from '@novasamatech/host-api';
 import { injectExtension } from '@polkadot/extension-inject';
+import { AccountId } from '@polkadot-api/substrate-bindings';
 import { SpektrExtensionName, Version } from './constants.js';
 import { defaultTransport } from './defaultTransport.js';
+const UNSUPPORTED_VERSION_ERROR = 'Unsupported message version';
 export async function createExtensionEnableFactory(transport) {
     const ready = await transport.isReady();
     if (!ready)
         return null;
+    const hostApi = createHostApi(transport);
+    const accountId = AccountId();
     async function enable() {
+        async function getAccounts() {
+            const response = await hostApi.get_non_product_accounts(enumValue('v1', undefined));
+            return response.match(response => {
+                assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
+                return response.value.map(account => ({
+                    name: account.name,
+                    address: accountId.dec(account.publicKey),
+                }));
+            }, err => {
+                assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
+                throw err.value;
+            });
+        }
         return {
             accounts: {
-                get() {
-                    return transport
-                        .request({ tag: 'getAccountsRequestV1', value: undefined }, 'getAccountsResponseV1')
-                        .then(v => unwrapResultOrThrow(v, e => new Error(e)));
+                async get() {
+                    return getAccounts();
                 },
                 subscribe(callback) {
-                    const unsubscribe = transport.subscribe('getAccountsResponseV1', (_, payload) => {
-                        try {
-                            const accounts = unwrapResultOrThrow(payload, e => new Error(e));
-                            callback(accounts);
-                        }
-                        catch {
-                            transport.provider.logger.error('Failed response on account subscription', payload.value);
-                        }
-                    });
-                    transport.postMessage('_', { tag: 'accountSubscriptionV1', value: undefined });
+                    getAccounts().then(callback);
                     return () => {
-                        transport.postMessage('_', { tag: 'accountUnsubscriptionV1', value: undefined });
-                        unsubscribe();
+                        // empty
                     };
                 },
             },
             signer: {
-                signRaw(raw) {
-                    return transport
-                        .request({ tag: 'signRawRequestV1', value: raw }, 'signResponseV1')
-                        .then(v => unwrapResultOrThrow(v, e => new Error(e)));
+                async signRaw(raw) {
+                    const payload = {
+                        address: raw.address,
+                        data: raw.type === 'bytes'
+                            ? {
+                                tag: 'Bytes',
+                                value: fromHex(raw.data),
+                            }
+                            : {
+                                tag: 'Payload',
+                                value: raw.data,
+                            },
+                    };
+                    const response = await hostApi.sign_raw(enumValue('v1', payload));
+                    return response.match(response => {
+                        assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
+                        return {
+                            id: 0,
+                            signature: response.value.signature,
+                            signedTransaction: response.value.signedTransaction,
+                        };
+                    }, err => {
+                        assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
+                        throw err.value;
+                    });
                 },
-                signPayload(payload) {
+                async signPayload(payload) {
                     const codecPayload = {
                         ...payload,
                         method: payload.method,
@@ -46,14 +72,28 @@ export async function createExtensionEnableFactory(transport) {
                         withSignedTransaction: payload.withSignedTransaction,
                         metadataHash: payload.metadataHash,
                     };
-                    return transport
-                        .request({ tag: 'signPayloadRequestV1', value: codecPayload }, 'signResponseV1')
-                        .then(v => unwrapResultOrThrow(v, e => new Error(e)));
+                    const response = await hostApi.sign_payload(enumValue('v1', codecPayload));
+                    return response.match(response => {
+                        assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
+                        return {
+                            id: 0,
+                            signature: response.value.signature,
+                            signedTransaction: response.value.signedTransaction,
+                        };
+                    }, err => {
+                        assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
+                        throw err.value;
+                    });
                 },
-                createTransaction(payload) {
-                    return transport
-                        .request({ tag: 'createTransactionRequestV1', value: payload }, 'createTransactionResponseV1')
-                        .then(v => unwrapResultOrThrow(v, e => new Error(e)));
+                async createTransaction(payload) {
+                    const response = await hostApi.create_transaction_with_non_product_account(enumValue('v1', payload));
+                    return response.match(response => {
+                        assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
+                        return toHex(response.value);
+                    }, err => {
+                        assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
+                        throw err.value;
+                    });
                 },
             },
         };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/product-sdk",
   "type": "module",
-  "version": "0.5.0-18",
+  "version": "0.5.0-19",
   "description": "Polkadot product SDK: integrate and run your product inside Polkadot browser.",
   "license": "Apache-2.0",
   "repository": {
@@ -27,9 +27,10 @@
   ],
   "dependencies": {
     "@polkadot/extension-inject": "^0.62.6",
+    "@polkadot-api/substrate-bindings": "^0.16.6",
     "@polkadot-api/json-rpc-provider": "^0.0.4",
     "@polkadot-api/json-rpc-provider-proxy": "^0.2.7",
-    "@novasamatech/host-api": "0.5.0-18"
+    "@novasamatech/host-api": "0.5.0-19"
   },
   "publishConfig": {
     "access": "public"

package/dist/createSpektrMetaProvider.js

@@ -1,21 +0,0 @@
-import { defaultTransport } from './defaultTransport.js';
-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.js

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

@@ -1,21 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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

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

package/dist/inject.js

@@ -1,60 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

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

package/dist/utils.d.ts

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

package/dist/utils.js

@@ -1,14 +0,0 @@
-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');
-}