@novasamatech/product-sdk 0.5.2 → 0.5.4-0

package/dist/injectSpektrExtension.js

@@ -12,7 +12,7 @@ export async function createExtensionEnableFactory(transport) {
     const accountId = AccountId();
     async function enable() {
         async function getAccounts() {
-            const response = await hostApi.get_non_product_accounts(enumValue('v1', undefined));
+            const response = await hostApi.getNonProductAccounts(enumValue('v1', undefined));
             return response.match(response => {
                 assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
                 return response.value.map(account => ({
@@ -51,7 +51,7 @@ export async function createExtensionEnableFactory(transport) {
                                 value: raw.data,
                             },
                     };
-                    const response = await hostApi.sign_raw(enumValue('v1', payload));
+                    const response = await hostApi.signRaw(enumValue('v1', payload));
                     return response.match(response => {
                         assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
                         return {
@@ -73,7 +73,7 @@ export async function createExtensionEnableFactory(transport) {
                         withSignedTransaction: payload.withSignedTransaction,
                         metadataHash: payload.metadataHash,
                     };
-                    const response = await hostApi.sign_payload(enumValue('v1', codecPayload));
+                    const response = await hostApi.signPayload(enumValue('v1', codecPayload));
                     return response.match(response => {
                         assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
                         return {
@@ -87,7 +87,7 @@ export async function createExtensionEnableFactory(transport) {
                     });
                 },
                 async createTransaction(payload) {
-                    const response = await hostApi.create_transaction_with_non_product_account(enumValue('v1', payload));
+                    const response = await hostApi.createTransactionWithNonProductAccount(enumValue('v1', payload));
                     return response.match(response => {
                         assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
                         return toHex(response.value);

package/dist/injectWeb3.d.ts

@@ -0,0 +1,24 @@
+import type { CodecType, HexString, Transport, VersionedPublicTxPayload } 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: CodecType<typeof VersionedPublicTxPayload>) => Promise<HexString>;
+}
+interface Injected {
+    accounts: InjectedAccounts;
+    signer: Signer;
+}
+export declare function createNonProductExtensionEnableFactory(transport: Transport): Promise<(() => Promise<Injected>) | null>;
+export declare function injectSpektrExtension(transport?: Transport | null): Promise<boolean>;
+export {};

package/dist/injectWeb3.js

@@ -0,0 +1,121 @@
+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 { sandboxTransport } from './sandboxTransport.js';
+const UNSUPPORTED_VERSION_ERROR = 'Unsupported message version';
+export async function createNonProductExtensionEnableFactory(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.getNonProductAccounts(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),
+                    type: 'sr25519',
+                }));
+            }, err => {
+                assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
+                throw err.value;
+            });
+        }
+        return {
+            accounts: {
+                async get() {
+                    return getAccounts();
+                },
+                subscribe(callback) {
+                    getAccounts().then(callback);
+                    return () => {
+                        // empty
+                    };
+                },
+            },
+            signer: {
+                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.signRaw(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;
+                    });
+                },
+                async signPayload(payload) {
+                    const codecPayload = {
+                        ...payload,
+                        method: payload.method,
+                        assetId: payload.assetId,
+                        mode: payload.mode,
+                        withSignedTransaction: payload.withSignedTransaction,
+                        metadataHash: payload.metadataHash,
+                    };
+                    const response = await hostApi.signPayload(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;
+                    });
+                },
+                async createTransaction(payload) {
+                    const response = await hostApi.createTransactionWithNonProductAccount(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;
+                    });
+                },
+            },
+        };
+    }
+    return enable;
+}
+export async function injectSpektrExtension(transport = sandboxTransport) {
+    if (!transport)
+        return false;
+    try {
+        const enable = await createNonProductExtensionEnableFactory(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/metaProvider.d.ts

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

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.2",
+  "version": "0.5.4-0",
   "description": "Polkadot product SDK: integrate and run your product inside Polkadot browser.",
   "license": "Apache-2.0",
   "repository": {
@@ -27,10 +27,10 @@
   ],
   "dependencies": {
     "@polkadot/extension-inject": "^0.62.6",
-    "@polkadot-api/substrate-bindings": "^0.16.6",
+    "@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.2"
+    "@novasamatech/host-api": "0.5.4-0"
   },
   "publishConfig": {
     "access": "public"