@novasamatech/product-sdk 0.7.8 → 0.7.9-1

package/README.md

@@ -211,15 +211,12 @@ subscription.unsubscribe();
 The Accounts Provider allows you to access product accounts and create signers for signing transactions.
 
 ```ts
-import { createAccountsProvider } from '@novasamatech/product-sdk';
+import { accounts } from '@novasamatech/product-sdk';
 import type { ProductAccount } from '@novasamatech/product-sdk';
 
-// Create accounts provider instance
-const accountsProvider = createAccountsProvider();
-
 // Get the user's primary DotNS username (RFC-0014)
 // — prompts for permission on first call
-const userIdResult = await accountsProvider.getUserId();
+const userIdResult = await accounts.getUserId();
 
 if (userIdResult.isOk()) {
   const { primaryUsername } = userIdResult.value;
@@ -234,7 +231,7 @@ if (userIdResult.isOk()) {
 }
 
 // Request login — triggers host sign-in UI; reason is shown to the user
-const loginResult = await accountsProvider.requestLogin('Sign in to access your account');
+const loginResult = await accounts.requestLogin('Sign in to access your account');
 
 if (loginResult.isOk()) {
   const outcome = loginResult.value; // 'success' | 'alreadyConnected' | 'rejected'
@@ -246,7 +243,7 @@ if (loginResult.isOk()) {
 }
 
 // Get a product account by DotNS identifier and derivation index
-const accountResult = await accountsProvider.getProductAccount('product.dot', 0);
+const accountResult = await accounts.getProductAccount('product.dot', 0);
 
 if (accountResult.isOk()) {
   const account: ProductAccount = accountResult.value;
@@ -254,42 +251,49 @@ if (accountResult.isOk()) {
 }
 
 // Get account alias
-const aliasResult = await accountsProvider.getProductAccountAlias('product.dot', 0);
+const aliasResult = await accounts.getProductAccountAlias('product.dot', 0);
 
 if (aliasResult.isOk()) {
   console.log('Alias:', aliasResult.value);
 }
 
 // Get legacy accounts (external wallets)
-const legacyAccountsResult = await accountsProvider.getLegacyAccounts();
+const legacyAccountsResult = await accounts.getLegacyAccounts();
 
 if (legacyAccountsResult.isOk()) {
   console.log('Legacy accounts:', legacyAccountsResult.value);
 }
 
 // Subscribe to account connection status changes
-const unsubscribe = accountsProvider.subscribeAccountConnectionStatus((status) => {
+const unsubscribe = accounts.subscribeAccountConnectionStatus((status) => {
   // status: 'connected' | 'disconnected'
   console.log('Account connection status:', status);
 });
 
-// Create a signer for a product account (for use with PAPI)
-const account: ProductAccount = {
-  dotNsIdentifier: 'product.dot',
-  derivationIndex: 0,
-  publicKey: new Uint8Array([/* ... */])
-};
-const signer = accountsProvider.getProductAccountSigner(account);
+// Create a signer for a product account (for use with PAPI).
+// Resolve the account first, then hand it to the signer factory.
+const productAccountResult = await accounts.getProductAccount('product.dot', 0);
 
-// Create a signer for a legacy account
-const legacySigner = accountsProvider.getLegacyAccountSigner(account);
+if (productAccountResult.isOk()) {
+  const productSigner = accounts.getProductAccountSigner(productAccountResult.value);
+  const signedTx = await tx.signAndSubmit(productSigner);
+}
 
-// PAPI transaction signing example
+// Create a signer for a legacy account.
+// Fetch the legacy account list, pick one, then pass it to the signer factory.
+const legacyAccountsResult = await accounts.getLegacyAccounts();
 
-const productAccountSignedTx = await tx.signAndSubmit(signer);
-const legacyAccountSignedTx = await tx.signAndSubmit(legacySigner);
+if (legacyAccountsResult.isOk()) {
+  const [legacyAccount] = legacyAccountsResult.value;
+  if (legacyAccount) {
+    const legacySigner = accounts.getLegacyAccountSigner(legacyAccount);
+    const signedTx = await tx.signAndSubmit(legacySigner);
+  }
+}
 ```
 
+> If you need a non-default transport (e.g. for tests or multi-host setups), use `createAccountsProvider(transport)` to build your own instance with the same API.
+
 ### Local Storage
 
 The Local Storage module provides a way to persist data in the host application's storage.

package/dist/accounts.d.ts

@@ -1,11 +1,13 @@
-import type { AccountConnectionStatus as AccountConnectionStatusCodec, CodecType, Subscription, Transport } from '@novasamatech/host-api';
+import type { AccountConnectionStatus as AccountConnectionStatusCodec, CodecType, LegacyAccount as LegacyAccountCodec, ProductAccountId as ProductAccountIdCodec, Subscription, Transport } from '@novasamatech/host-api';
 import { RingLocation } from '@novasamatech/host-api';
 import type { PolkadotSigner } from 'polkadot-api';
+export type ProductAccountId = CodecType<typeof ProductAccountIdCodec>;
 export type ProductAccount = {
     dotNsIdentifier: string;
     derivationIndex: number;
     publicKey: Uint8Array;
 };
+export type LegacyAccount = CodecType<typeof LegacyAccountCodec>;
 export type AccountConnectionStatus = CodecType<typeof AccountConnectionStatusCodec>;
 export declare const createAccountsProvider: (transport?: Transport) => {
     getUserId(): import("neverthrow").ResultAsync<{
@@ -18,6 +20,8 @@ export declare const createAccountsProvider: (transport?: Transport) => {
     }, "LoginErr::Unknown">>;
     getProductAccount(dotNsIdentifier: string, derivationIndex?: number): import("neverthrow").ResultAsync<{
         publicKey: Uint8Array<ArrayBufferLike>;
+        dotNsIdentifier: string;
+        derivationIndex: number;
     }, import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::NotConnected"> | import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::Rejected"> | import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::DomainNotValid"> | import("@novasamatech/scale").CodecError<{
         reason: string;
     }, "RequestCredentialsErr::Unknown">>;
@@ -36,7 +40,54 @@ export declare const createAccountsProvider: (transport?: Transport) => {
     createRingVRFProof(dotNsIdentifier: string, derivationIndex: number | undefined, location: CodecType<typeof RingLocation>, message: Uint8Array): import("neverthrow").ResultAsync<Uint8Array<ArrayBufferLike>, import("@novasamatech/scale").CodecError<undefined, "CreateProofErr::Rejected"> | import("@novasamatech/scale").CodecError<{
         reason: string;
     }, "CreateProofErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "CreateProofErr::RingNotFound">>;
-    getProductAccountSigner(account: ProductAccount): PolkadotSigner;
+    /**
+     * Builds a `PolkadotSigner` that delegates to the host via `host_create_transaction`.
+     *
+     * 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`.
+     */
+    getProductAccountSigner(account: ProductAccount, signerType?: "signPayload" | "createTransaction"): PolkadotSigner;
     subscribeAccountConnectionStatus(callback: (status: AccountConnectionStatus) => void): Subscription<void>;
-    getLegacyAccountSigner(account: ProductAccount): PolkadotSigner;
+    getLegacyAccountSigner(account: LegacyAccount): PolkadotSigner;
+};
+export declare const accounts: {
+    getUserId(): import("neverthrow").ResultAsync<{
+        primaryUsername: string;
+    }, import("@novasamatech/scale").CodecError<undefined, "GetUserIdErr::NotConnected"> | import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "GetUserIdErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "GetUserIdErr::PermissionDenied">>;
+    requestLogin(reason?: string): import("neverthrow").ResultAsync<"success" | "alreadyConnected" | "rejected", import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "LoginErr::Unknown">>;
+    getProductAccount(dotNsIdentifier: string, derivationIndex?: number): import("neverthrow").ResultAsync<{
+        publicKey: Uint8Array<ArrayBufferLike>;
+        dotNsIdentifier: string;
+        derivationIndex: number;
+    }, import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::NotConnected"> | import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::Rejected"> | import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::DomainNotValid"> | import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "RequestCredentialsErr::Unknown">>;
+    getProductAccountAlias(dotNsIdentifier: string, derivationIndex?: number): import("neverthrow").ResultAsync<{
+        context: Uint8Array<ArrayBufferLike>;
+        alias: Uint8Array<ArrayBufferLike>;
+    }, import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::NotConnected"> | import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::Rejected"> | import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::DomainNotValid"> | import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "RequestCredentialsErr::Unknown">>;
+    getLegacyAccounts(): import("neverthrow").ResultAsync<{
+        publicKey: Uint8Array<ArrayBufferLike>;
+        name: string | undefined;
+    }[], import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::NotConnected"> | import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::Rejected"> | import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::DomainNotValid"> | import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "RequestCredentialsErr::Unknown">>;
+    createRingVRFProof(dotNsIdentifier: string, derivationIndex: number | undefined, location: CodecType<typeof RingLocation>, message: Uint8Array): import("neverthrow").ResultAsync<Uint8Array<ArrayBufferLike>, import("@novasamatech/scale").CodecError<undefined, "CreateProofErr::Rejected"> | import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "CreateProofErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "CreateProofErr::RingNotFound">>;
+    /**
+     * Builds a `PolkadotSigner` that delegates to the host via `host_create_transaction`.
+     *
+     * 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`.
+     */
+    getProductAccountSigner(account: ProductAccount, signerType?: "signPayload" | "createTransaction"): PolkadotSigner;
+    subscribeAccountConnectionStatus(callback: (status: AccountConnectionStatus) => void): Subscription<void>;
+    getLegacyAccountSigner(account: LegacyAccount): PolkadotSigner;
 };

package/dist/accounts.js

@@ -1,4 +1,5 @@
 import { CreateProofErr, GetUserIdErr, LoginErr, RequestCredentialsErr, RingLocation, SigningPayload, SigningPayloadWithoutAccount, SigningRawPayload, SigningRawPayloadWithoutAccount, assertEnumVariant, createHostApi, enumValue, fromHex, isEnumVariant, toHex, } from '@novasamatech/host-api';
+import { decAnyMetadata, unifyMetadata } from '@polkadot-api/substrate-bindings';
 import { err, ok } from 'neverthrow';
 import { getPolkadotSignerFromPjs } from 'polkadot-api/pjs-signer';
 import { sandboxTransport } from './sandboxTransport.js';
@@ -36,7 +37,11 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
                 .mapErr(e => e.value)
                 .andThen(response => {
                 if (isEnumVariant(response, 'v1')) {
-                    return ok(response.value);
+                    return ok({
+                        publicKey: response.value.publicKey,
+                        dotNsIdentifier,
+                        derivationIndex,
+                    });
                 }
                 // @ts-expect-error response.tag is never here
                 return err(new RequestCredentialsErr.Unknown({ reason: `Unsupported response version ${response.tag}` }));
@@ -78,50 +83,103 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
                 return err(new CreateProofErr.Unknown({ reason: `Unsupported response version ${response.tag}` }));
             });
         },
-        getProductAccountSigner(account) {
-            return getPolkadotSignerFromPjs(toHex(account.publicKey), async (payload) => {
-                const codecPayload = {
-                    account: [account.dotNsIdentifier, account.derivationIndex],
-                    payload: buildSigningPayloadFields(payload),
-                };
-                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,
+        /**
+         * Builds a `PolkadotSigner` that delegates to the host via `host_create_transaction`.
+         *
+         * 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`.
+         */
+        getProductAccountSigner(account, signerType = 'signPayload') {
+            const hostApi = createHostApi(transport);
+            const productAccountId = [account.dotNsIdentifier, account.derivationIndex];
+            /**
+             * @deprecated added for backward compatibility
+             */
+            if (signerType === 'signPayload') {
+                return getPolkadotSignerFromPjs(toHex(account.publicKey), async (payload) => {
+                    const codecPayload = {
+                        account: [account.dotNsIdentifier, account.derivationIndex],
+                        payload: buildSigningPayloadFields(payload),
                     };
-                }, err => {
-                    assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
-                    throw err.value;
-                });
-            }, async (raw) => {
-                const payload = {
-                    account: [account.dotNsIdentifier, account.derivationIndex],
-                    payload: raw.type === 'bytes'
-                        ? {
-                            tag: 'Bytes',
-                            value: fromHex(asHex(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,
+                    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 (raw) => {
+                    const payload = {
+                        account: [account.dotNsIdentifier, account.derivationIndex],
+                        payload: raw.type === 'bytes'
+                            ? {
+                                tag: 'Bytes',
+                                value: fromHex(asHex(raw.data)),
+                            }
+                            : {
+                                tag: 'Payload',
+                                value: raw.data,
+                            },
                     };
-                }, err => {
-                    assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
-                    throw err.value;
+                    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;
+                    });
                 });
-            });
+            }
+            return {
+                publicKey: account.publicKey,
+                async signTx(callData, signedExtensions, metadata) {
+                    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 = {
+                        signer: productAccountId,
+                        callData,
+                        extensions: Object.values(signedExtensions).map(({ identifier, value, additionalSigned }) => ({
+                            id: identifier,
+                            extra: value,
+                            additionalSigned: additionalSigned,
+                        })),
+                        txExtVersion,
+                    };
+                    const response = await hostApi.createTransaction(enumValue('v1', 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: productAccountId,
+                        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;
+                    });
+                },
+            };
         },
         subscribeAccountConnectionStatus(callback) {
             const subscriber = hostApi.accountConnectionStatusSubscribe(enumValue('v1', undefined), status => {
@@ -173,6 +231,7 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
         },
     };
 };
+export const accounts = createAccountsProvider();
 function asHex(v) {
     if (v.startsWith('0x'))
         return v;

package/dist/index.d.ts

@@ -8,8 +8,8 @@ export type { ChatBotRegistrationResult, ChatCustomMessageRenderer, ChatCustomMe
 export { createProductChatManager, matchChatCustomRenderers } from './chat.js';
 export type { ProductAccountId, SignedStatement, Statement, StatementTopicFilter, StatementsPage, Topic, } from './statementStore.js';
 export { createStatementStore } from './statementStore.js';
-export type { AccountConnectionStatus, ProductAccount } from './accounts.js';
-export { createAccountsProvider } from './accounts.js';
+export type { AccountConnectionStatus, LegacyAccount, ProductAccount } from './accounts.js';
+export { accounts, createAccountsProvider } from './accounts.js';
 export type { ThemeMode } from './theme.js';
 export { createThemeProvider } from './theme.js';
 export { createLocalStorage, hostLocalStorage } from './localStorage.js';

package/dist/index.js

@@ -6,7 +6,7 @@ export { createLegacyExtensionEnableFactory, injectSpektrExtension } from './inj
 export { createPapiProvider } from './papiProvider.js';
 export { createProductChatManager, matchChatCustomRenderers } from './chat.js';
 export { createStatementStore } from './statementStore.js';
-export { createAccountsProvider } from './accounts.js';
+export { accounts, createAccountsProvider } from './accounts.js';
 export { createThemeProvider } from './theme.js';
 export { createLocalStorage, hostLocalStorage } from './localStorage.js';
 export { createPreimageManager, preimageManager } from './preimage.js';

package/dist/injectWeb3.d.ts

@@ -1,6 +1,72 @@
-import type { CodecType, HexString, Transport, VersionedPublicTxPayload } from '@novasamatech/host-api';
+import type { HexString, Transport } from '@novasamatech/host-api';
 import type { InjectedAccounts } from '@polkadot/extension-inject/types';
 import type { SignerPayloadJSON, SignerPayloadRaw, SignerResult } from '@polkadot/types/types/extrinsic';
+/**
+ * expected interface derived from specification
+ */
+export interface TxPayloadV1 {
+    /** Payload version. MUST be 1. */
+    version: 1;
+    /**
+     * Signer selection hint. Allows the implementer to identify which private-key / scheme to use.
+     * - Use a wallet-defined handle (e.g., address/SS58, account-name, etc). This identifier
+     * was previously made available to the consumer.
+     * - Set `null` to let the implementer pick the signer (or if the signer is implied).
+     */
+    signer: string | null;
+    /**
+     * SCALE-encoded Call (module indicator + function indicator + params).
+     */
+    callData: HexString;
+    /**
+     * Transaction extensions supplied by the caller (order irrelevant).
+     * The consumer SHOULD provide every extension that is relevant to them.
+     * The implementer MAY infer missing ones.
+     */
+    extensions: Array<{
+        /** Identifier as defined in metadata (e.g., "CheckSpecVersion", "ChargeAssetTxPayment"). */
+        id: string;
+        /**
+         * Explicit "extra" to sign (goes into the extrinsic body).
+         * SCALE-encoded per the extension's "extra" type as defined in the metadata.
+         */
+        extra: HexString;
+        /**
+         * "Implicit" data to sign (known by the chain, not included into the extrinsic body).
+         * SCALE-encoded per the extension's "additionalSigned" type as defined in the metadata.
+         */
+        additionalSigned: HexString;
+    }>;
+    /**
+     * Transaction Extension Version.
+     * - For Extrinsic V4 MUST be 0.
+     * - For Extrinsic V5, set to any version supported by the runtime.
+     * The implementer:
+     *  - MUST use this field to determine the required extensions for creating the extrinsic.
+     *  - MAY use this field to infer missing extensions that the implementer could know how to handle.
+     */
+    txExtVersion: number;
+    /**
+     * Context needed for decoding, display, and (optionally) inferring certain extensions.
+     */
+    context: {
+        /**
+         * RuntimeMetadataPrefixed blob (SCALE), starting with ASCII "meta" magic (`0x6d657461`),
+         * then a metadata version (V14+). For V5+ versioned extensions, MUST provide V16+.
+         */
+        metadata: HexString;
+        /**
+         * Native token display info (used by some implementers), also needed to compute
+         * the `CheckMetadataHash` value.
+         */
+        tokenSymbol: string;
+        tokenDecimals: number;
+        /**
+         * Highest known block number to aid mortality UX.
+         */
+        bestBlockHeight: number;
+    };
+}
 interface Signer {
     /**
      * @description signs an extrinsic payload from a serialized form
@@ -13,7 +79,7 @@ interface Signer {
     /**
      * @description signs a transaction according to https://github.com/polkadot-js/api/issues/6213
      */
-    createTransaction?: (payload: CodecType<typeof VersionedPublicTxPayload>) => Promise<HexString>;
+    createTransaction?: (payload: TxPayloadV1) => Promise<HexString>;
 }
 interface Injected {
     accounts: InjectedAccounts;

package/dist/injectWeb3.js

@@ -1,6 +1,7 @@
 import { assertEnumVariant, createHostApi, enumValue, fromHex, toHex } from '@novasamatech/host-api';
 import { injectExtension } from '@polkadot/extension-inject';
 import { AccountId } from 'polkadot-api';
+import { createAccountsProvider } from './accounts.js';
 import { SpektrExtensionName, Version } from './constants.js';
 import { sandboxTransport } from './sandboxTransport.js';
 const UNSUPPORTED_VERSION_ERROR = 'Unsupported message version';
@@ -8,21 +9,22 @@ export async function createLegacyExtensionEnableFactory(transport) {
     const ready = await transport.isReady();
     if (!ready)
         return null;
+    const accountsManager = createAccountsProvider(transport);
     const hostApi = createHostApi(transport);
     const accountId = AccountId();
     async function enable() {
         async function getAccounts() {
-            const response = await hostApi.getLegacyAccounts(enumValue('v1', undefined));
-            return response.match(response => {
-                assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
-                return response.value.map(account => ({
+            return await accountsManager
+                .getLegacyAccounts()
+                .map(response => {
+                return response.map(account => ({
                     name: account.name,
                     address: accountId.dec(account.publicKey),
                     type: 'sr25519',
                 }));
-            }, err => {
-                assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
-                throw err.value;
+            })
+                .match(x => x, x => {
+                throw x;
             });
         }
         return {
@@ -99,7 +101,24 @@ export async function createLegacyExtensionEnableFactory(transport) {
                     });
                 },
                 async createTransaction(payload) {
-                    const response = await hostApi.createTransactionWithLegacyAccount(enumValue('v1', payload));
+                    if (payload.version !== 1) {
+                        throw new Error(`Signer support only v1 transaction, got version = ${payload.version}`);
+                    }
+                    const { signer } = payload;
+                    if (!signer) {
+                        throw new Error("Signer can't route transaction to the right account without signer hint.");
+                    }
+                    const possibleAccountId = accountId.enc(signer);
+                    const response = await hostApi.createTransactionWithLegacyAccount(enumValue('v1', {
+                        signer: possibleAccountId,
+                        callData: fromHex(payload.callData),
+                        txExtVersion: payload.txExtVersion,
+                        extensions: payload.extensions.map(e => ({
+                            id: e.id,
+                            additionalSigned: fromHex(e.additionalSigned),
+                            extra: fromHex(e.extra),
+                        })),
+                    }));
                     return response.match(response => {
                         assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
                         return toHex(response.value);

package/package.json

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