@novasamatech/product-sdk 0.5.3-0 → 0.5.4-0

package/dist/metaProvider.js

@@ -0,0 +1,24 @@
+import { sandboxTransport } from './sandboxTransport.js';
+export function createMetaProvider(transport = sandboxTransport) {
+    // 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 metaProvider = createMetaProvider();

package/dist/papiProvider.d.ts

@@ -0,0 +1,7 @@
+import type { HexString, Transport } from '@novasamatech/host-api';
+import type { JsonRpcProvider } from '@polkadot-api/json-rpc-provider';
+type InternalParams = {
+    transport?: Transport;
+};
+export declare function createPapiProvider(genesisHash: HexString, __fallback?: JsonRpcProvider, internal?: InternalParams): JsonRpcProvider;
+export {};

package/dist/papiProvider.js

@@ -0,0 +1,60 @@
+import { createHostApi, enumValue, unwrapResultOrThrow } from '@novasamatech/host-api';
+import { getSyncProvider } from '@polkadot-api/json-rpc-provider-proxy';
+import { sandboxTransport } from './sandboxTransport.js';
+export function createPapiProvider(genesisHash, 
+// for testing purposes only, should not be used in real production code
+__fallback, internal) {
+    const version = 'v1';
+    const transport = internal?.transport ?? sandboxTransport;
+    if (!transport.isCorrectEnvironment()) {
+        throw new Error('PapiProvider can only be used in a product environment');
+    }
+    const hostApi = createHostApi(transport);
+    const spektrProvider = onMessage => {
+        const subscription = hostApi.jsonrpcMessageSubscribe(enumValue(version, genesisHash), payload => {
+            switch (payload.tag) {
+                case version:
+                    onMessage(payload.value);
+                    break;
+                default:
+                    transport.provider.logger.error('Unknown message version', payload.tag);
+            }
+        });
+        return {
+            send(message) {
+                hostApi.jsonrpcMessageSend(enumValue(version, [genesisHash, message]));
+            },
+            disconnect() {
+                subscription.unsubscribe();
+            },
+        };
+    };
+    function checkIfReady() {
+        return transport.isReady().then(ready => {
+            if (!ready)
+                return false;
+            return transport
+                .request('feature', enumValue('v1', enumValue('Chain', genesisHash)))
+                .then(payload => {
+                switch (payload.tag) {
+                    case 'v1': {
+                        return unwrapResultOrThrow(payload.value, e => new Error(e.payload.reason));
+                    }
+                    default:
+                        throw new Error(`Unknown message version ${payload.tag}`);
+                }
+            })
+                .catch(e => {
+                transport.provider.logger.error('Error checking chain support', e);
+                return false;
+            });
+        });
+    }
+    return getSyncProvider(() => checkIfReady().then(ready => {
+        if (ready)
+            return spektrProvider;
+        if (__fallback)
+            return __fallback;
+        throw new Error(`Chain ${genesisHash} not supported by host`);
+    }));
+}

package/dist/sandboxTransport.d.ts

@@ -0,0 +1,8 @@
+import type { Provider } from '@novasamatech/host-api';
+declare global {
+    interface Window {
+        __HOST_API_PORT__?: MessagePort;
+    }
+}
+export declare const sandboxProvider: Provider;
+export declare const sandboxTransport: import("@novasamatech/host-api").Transport;

package/dist/sandboxTransport.js

@@ -0,0 +1,85 @@
+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 isWebview() {
+    try {
+        return window['__HOST_API_PORT__'] !== undefined;
+    }
+    catch {
+        return false;
+    }
+}
+function getWebviewPort() {
+    if (window['__HOST_API_PORT__']) {
+        return window['__HOST_API_PORT__'];
+    }
+    throw new Error('No webview port found');
+}
+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) => {
+        const source = isIframe() ? getParentWindow() : isWebview() ? getWebviewPort() : null;
+        if (!source)
+            throw new Error('No message source found');
+        if (!isValidMessage(event, source, window))
+            return;
+        for (const subscriber of subscribers) {
+            subscriber(event.data);
+        }
+    };
+    if (isIframe()) {
+        window.addEventListener('message', handleMessage);
+    }
+    else if (isWebview()) {
+        getWebviewPort().addEventListener('message', handleMessage);
+    }
+    return {
+        logger: createDefaultLogger(),
+        isCorrectEnvironment() {
+            return isIframe() || isWebview();
+        },
+        postMessage(message) {
+            if (isIframe()) {
+                getParentWindow().postMessage(message, '*', [message.buffer]);
+            }
+            else if (isWebview()) {
+                getWebviewPort().postMessage(message, [message.buffer]);
+            }
+        },
+        subscribe(callback) {
+            subscribers.add(callback);
+            return () => {
+                subscribers.delete(callback);
+            };
+        },
+        dispose() {
+            subscribers.clear();
+            if (isIframe()) {
+                window.removeEventListener('message', handleMessage);
+            }
+            if (isWebview()) {
+                getWebviewPort().removeEventListener('message', handleMessage);
+            }
+        },
+    };
+}
+export const sandboxProvider = createDefaultSdkProvider();
+export const sandboxTransport = createTransport(sandboxProvider);

package/dist/statementStore.d.ts

@@ -0,0 +1,36 @@
+import type { CodecType, ProductAccountId as ProductAccountIdCodec, SignedStatement as SignedStatementCodec, Statement as StatementCodec, Topic as TopicCodec, Transport } from '@novasamatech/host-api';
+export type Statement = CodecType<typeof StatementCodec>;
+export type SignedStatement = CodecType<typeof SignedStatementCodec>;
+export type Topic = CodecType<typeof TopicCodec>;
+export type ProductAccountId = CodecType<typeof ProductAccountIdCodec>;
+export declare const createStatementStore: (transport?: Transport) => {
+    query(topics: Topic[]): Promise<SignedStatement[]>;
+    subscribe(topics: Topic[], callback: (statements: SignedStatement[]) => void): import("@novasamatech/host-api").Subscription;
+    createProof(accountId: ProductAccountId, statement: Statement): Promise<{
+        tag: "Sr25519";
+        value: {
+            signature: Uint8Array<ArrayBufferLike>;
+            signer: Uint8Array<ArrayBufferLike>;
+        };
+    } | {
+        tag: "Ed25519";
+        value: {
+            signature: Uint8Array<ArrayBufferLike>;
+            signer: Uint8Array<ArrayBufferLike>;
+        };
+    } | {
+        tag: "Ecdsa";
+        value: {
+            signature: Uint8Array<ArrayBufferLike>;
+            signer: Uint8Array<ArrayBufferLike>;
+        };
+    } | {
+        tag: "OnChain";
+        value: {
+            who: Uint8Array<ArrayBufferLike>;
+            blockHash: Uint8Array<ArrayBufferLike>;
+            event: bigint;
+        };
+    }>;
+    submit(signedStatement: SignedStatement): Promise<void>;
+};

package/dist/statementStore.js

@@ -0,0 +1,47 @@
+import { createHostApi, enumValue } from '@novasamatech/host-api';
+import { sandboxTransport } from './sandboxTransport.js';
+export const createStatementStore = (transport = sandboxTransport) => {
+    const hostApi = createHostApi(transport);
+    return {
+        async query(topics) {
+            const result = await hostApi.statementStoreQuery(enumValue('v1', topics));
+            return result.match(payload => {
+                if (payload.tag === 'v1') {
+                    return payload.value;
+                }
+                throw new Error(`Unknown response version ${payload.tag}`);
+            }, err => {
+                throw err.value;
+            });
+        },
+        subscribe(topics, callback) {
+            return hostApi.statementStoreSubscribe(enumValue('v1', topics), payload => {
+                if (payload.tag === 'v1') {
+                    callback(payload.value);
+                }
+            });
+        },
+        async createProof(accountId, statement) {
+            const result = await hostApi.statementStoreCreateProof(enumValue('v1', [accountId, statement]));
+            return result.match(payload => {
+                if (payload.tag === 'v1') {
+                    return payload.value;
+                }
+                throw new Error(`Unknown response version ${payload.tag}`);
+            }, err => {
+                throw err.value;
+            });
+        },
+        async submit(signedStatement) {
+            const result = await hostApi.statementStoreSubmit(enumValue('v1', signedStatement));
+            return result.match(payload => {
+                if (payload.tag === 'v1') {
+                    return;
+                }
+                throw new Error(`Unknown response version ${payload.tag}`);
+            }, err => {
+                throw err.value;
+            });
+        },
+    };
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/product-sdk",
   "type": "module",
-  "version": "0.5.3-0",
+  "version": "0.5.4-0",
   "description": "Polkadot product SDK: integrate and run your product inside Polkadot browser.",
   "license": "Apache-2.0",
   "repository": {
@@ -30,7 +30,7 @@
     "@polkadot-api/substrate-bindings": "^0.16.5",
     "@polkadot-api/json-rpc-provider": "^0.0.4",
     "@polkadot-api/json-rpc-provider-proxy": "^0.2.7",
-    "@novasamatech/host-api": "0.5.3-0"
+    "@novasamatech/host-api": "0.5.4-0"
   },
   "publishConfig": {
     "access": "public"