@novasamatech/product-sdk 0.7.9-2 → 0.7.9-4

package/dist/accounts.js

@@ -153,7 +153,7 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
                     }
                     const txPayload = {
                         signer: productAccountId,
-                        genesisHash: checkGenesis.value,
+                        genesisHash: checkGenesis.additionalSigned,
                         callData,
                         extensions: Object.values(signedExtensions).map(({ identifier, value, additionalSigned }) => ({
                             id: identifier,

package/dist/injectWeb3.js

@@ -115,7 +115,7 @@ export async function createLegacyExtensionEnableFactory(transport) {
                     const possibleAccountId = accountId.enc(signer);
                     const response = await hostApi.createTransactionWithLegacyAccount(enumValue('v1', {
                         signer: possibleAccountId,
-                        genesisHash: fromHex(checkGenesis.extra),
+                        genesisHash: fromHex(checkGenesis.additionalSigned),
                         callData: fromHex(payload.callData),
                         txExtVersion: payload.txExtVersion,
                         extensions: payload.extensions.map(e => ({

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/product-sdk",
   "type": "module",
-  "version": "0.7.9-2",
+  "version": "0.7.9-4",
   "description": "Polkadot product SDK: integrate and run your product inside Polkadot browser.",
   "license": "Apache-2.0",
   "repository": {
@@ -28,7 +28,7 @@
     "@polkadot/extension-inject": "^0.63.1",
     "@polkadot-api/json-rpc-provider-proxy": "^0.4.0",
     "@polkadot-api/substrate-bindings": "^0.20.2",
-    "@novasamatech/host-api": "0.7.9-2",
+    "@novasamatech/host-api": "0.7.9-4",
     "polkadot-api": ">=2",
     "neverthrow": "^8.2.0"
   },

package/dist/createMetaProvider.d.ts

@@ -1,7 +0,0 @@
-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/createMetaProvider.js

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

package/dist/createPapiProvider.d.ts

@@ -1,7 +0,0 @@
-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, internal?: InternalParams): JsonRpcProvider;
-export {};

package/dist/createPapiProvider.js

@@ -1,56 +0,0 @@
-import { createHostApi, enumValue, unwrapResultOrThrow } from '@novasamatech/host-api';
-import { getSyncProvider } from '@polkadot-api/json-rpc-provider-proxy';
-import { defaultTransport } from './defaultTransport.js';
-export function createPapiProvider(genesisHash, internal) {
-    const version = 'v1';
-    const transport = internal?.transport ?? defaultTransport;
-    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;
-        throw new Error(`Chain ${genesisHash} not supported by host`);
-    }));
-}

package/dist/defaultTransport.d.ts

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

package/dist/defaultTransport.js

@@ -1,57 +0,0 @@
-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);

package/dist/injectSpektrExtension.d.ts

@@ -1,24 +0,0 @@
-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 createExtensionEnableFactory(transport: Transport): Promise<(() => Promise<Injected>) | null>;
-export declare function injectSpektrExtension(transport?: Transport | null): Promise<boolean>;
-export {};

package/dist/injectSpektrExtension.js

@@ -1,121 +0,0 @@
-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.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 = 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/signer.d.ts

@@ -1,17 +0,0 @@
-import type { CodecType, ProductAccountId as ProductAccountIdCodec, Transport } from '@novasamatech/host-api';
-import type { PolkadotSigner } from 'polkadot-api';
-export type ProductAccountId = CodecType<typeof ProductAccountIdCodec>;
-export type ProductSignerConfig = {
-    /** Native token symbol — used by hosts that compute CheckMetadataHash or render fees. Defaults to "". */
-    tokenSymbol?: string;
-    /** Native token decimals — see tokenSymbol. Defaults to 0. */
-    tokenDecimals?: number;
-};
-/**
- * Builds a `PolkadotSigner` that delegates to the host via `host_create_transaction`
- * (the new signing flow described in https://github.com/polkadot-js/api/issues/6213).
- *
- * The factory is async because `PolkadotSigner.publicKey` must be a synchronous
- * `Uint8Array` on the returned object — it is fetched up front via `host_account_get`.
- */
-export declare const createProductSigner: (accountId: ProductAccountId, config?: ProductSignerConfig, transport?: Transport) => Promise<PolkadotSigner>;

package/dist/signer.js

@@ -1,71 +0,0 @@
-import { assertEnumVariant, createHostApi, enumValue, fromHex, toHex } from '@novasamatech/host-api';
-import { decAnyMetadata, unifyMetadata } from '@polkadot-api/substrate-bindings';
-import { sandboxTransport } from './sandboxTransport.js';
-const UNSUPPORTED_VERSION_ERROR = 'Unsupported message version';
-/**
- * Builds a `PolkadotSigner` that delegates to the host via `host_create_transaction`
- * (the new signing flow described in https://github.com/polkadot-js/api/issues/6213).
- *
- * The factory is async because `PolkadotSigner.publicKey` must be a synchronous
- * `Uint8Array` on the returned object — it is fetched up front via `host_account_get`.
- */
-export const createProductSigner = async (accountId, config = {}, transport = sandboxTransport) => {
-    const hostApi = createHostApi(transport);
-    const accountResponse = await hostApi.accountGet(enumValue('v1', accountId));
-    const account = accountResponse.match(response => {
-        assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
-        return response.value;
-    }, err => {
-        assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
-        throw err.value;
-    });
-    const tokenSymbol = config.tokenSymbol ?? 'DOT';
-    const tokenDecimals = config.tokenDecimals ?? 12;
-    return {
-        publicKey: account.publicKey,
-        async signTx(callData, signedExtensions, metadata, atBlockNumber) {
-            const decMeta = unifyMetadata(decAnyMetadata(metadata));
-            const { version: versions } = decMeta.extrinsic;
-            const latestVersion = versions.reduce((acc, v) => Math.max(acc, v), 0);
-            const txExtVersion = latestVersion === 4 ? 0 : latestVersion;
-            const txPayload = {
-                version: 1,
-                signer: null,
-                callData,
-                extensions: Object.values(signedExtensions).map(({ identifier, value, additionalSigned }) => ({
-                    id: identifier,
-                    extra: value,
-                    additionalSigned: additionalSigned,
-                })),
-                txExtVersion,
-                context: {
-                    metadata: metadata,
-                    tokenSymbol,
-                    tokenDecimals,
-                    bestBlockHeight: atBlockNumber,
-                },
-            };
-            const response = await hostApi.createTransaction(enumValue('v1', [accountId, txPayload]));
-            return response.match(response => {
-                assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
-                return response.value;
-            }, err => {
-                assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
-                throw err.value;
-            });
-        },
-        async signBytes(data) {
-            const response = await hostApi.signRaw(enumValue('v1', {
-                account: accountId,
-                payload: { tag: 'Bytes', value: data },
-            }));
-            return response.match(response => {
-                assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
-                return fromHex(response.value.signature);
-            }, err => {
-                assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
-                throw err.value;
-            });
-        },
-    };
-};