@parity/product-sdk-signer 0.4.0 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parity/product-sdk-signer",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Signer manager for Polkadot — Host API and dev accounts",
   "type": "module",
   "sideEffects": false,
@@ -18,18 +18,18 @@
     "src"
   ],
   "dependencies": {
-    "polkadot-api": "^2.1.2",
+    "polkadot-api": "^2.1.5",
+    "@parity/product-sdk-host": "0.6.1",
+    "@parity/product-sdk-keys": "0.3.3",
     "@parity/product-sdk-address": "0.1.1",
-    "@parity/product-sdk-host": "0.5.0",
-    "@parity/product-sdk-keys": "0.3.1",
     "@parity/product-sdk-logger": "0.1.1"
   },
   "optionalDependencies": {
-    "@novasamatech/host-api-wrapper": "^0.7.9",
-    "@novasamatech/host-api": "^0.7.9"
+    "@novasamatech/host-api-wrapper": "^0.8.4",
+    "@novasamatech/host-api": "^0.8.4"
   },
   "devDependencies": {
-    "tsup": "^8.4.0",
+    "tsup": "^8.5.1",
     "typescript": "^5.9.3",
     "vitest": "^3.1.4"
   },

package/src/errors.ts

@@ -1,3 +1,5 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
 import type { ProviderType } from "./types.js";
 
 /** Base class for all signer errors. Use `instanceof SignerError` to catch any signer-related error. */

package/src/index.ts

@@ -1,3 +1,5 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
 /**
  * @parity/product-sdk-signer — Account connection and signing, decoupled from where the keys actually live.
  *

package/src/providers/dev.ts

@@ -1,3 +1,5 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
 import { seedToAccount } from "@parity/product-sdk-keys";
 import { createLogger } from "@parity/product-sdk-logger";
 

package/src/providers/host.ts

@@ -1,3 +1,5 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
 import { deriveH160, ss58Encode } from "@parity/product-sdk-address";
 import { createLogger } from "@parity/product-sdk-logger";
 
@@ -48,6 +50,21 @@ export interface HostProviderOptions {
     requestChainSubmitPermission?: boolean;
     /** @deprecated Renamed to `requestChainSubmitPermission`. */
     requestTransactionSubmitPermission?: boolean;
+    /**
+     * If set, `connect()` returns a single product account for the given
+     * `dotNsIdentifier`, skipping the legacy fetch entirely. For apps
+     * that sign exclusively with a per-dapp derived account.
+     *
+     * `SignerAccount.name` is populated best-effort from
+     * `accounts.getUserId().primaryUsername`; failures leave it null.
+     * Signing is pinned to `createTransaction` (see PR #96).
+     */
+    productAccount?: {
+        /** App identifier (e.g., `"playground.dot"`). */
+        dotNsIdentifier: string;
+        /** Derivation index within the app scope. Default: 0. */
+        derivationIndex?: number;
+    };
 }
 
 /**
@@ -109,7 +126,7 @@ interface NeverthrowResultAsync<T, E> {
  * `"signPayload"` path wraps via PJS and throws
  * `"PJS does not support this signed-extension: AsPgas"` on those chains.
  *
- * Nova's `host-api-wrapper@0.7.9` already defaults to `"createTransaction"`,
+ * Nova's `host-api-wrapper@0.8.0` already defaults to `"createTransaction"`,
  * so this is a defensive pin rather than an opt-in — it guards against a
  * future upstream default flip and makes the routing legible at the call
  * site. The legacy-account signer doesn't expose this switch.
@@ -132,6 +149,7 @@ export interface AccountsProvider {
         dotNsIdentifier: string,
         derivationIndex?: number,
     ) => NeverthrowResultAsync<ContextualAlias, unknown>;
+    getUserId: () => NeverthrowResultAsync<{ primaryUsername: string }, unknown>;
     createRingVRFProof: (
         dotNsIdentifier: string,
         derivationIndex: number,
@@ -193,6 +211,7 @@ export class HostProvider implements SignerProvider {
     private readonly loadSdk: () => Promise<ProductSdkModule>;
     private readonly loadHostApiEnum: () => Promise<HostApiEnumHelper>;
     private readonly requestChainSubmitPermission: boolean;
+    private readonly productAccount: HostProviderOptions["productAccount"];
 
     private accountsProvider: AccountsProvider | null = null;
     private statusCleanup: (() => void) | null = null;
@@ -210,6 +229,7 @@ export class HostProvider implements SignerProvider {
             options?.requestChainSubmitPermission ??
             options?.requestTransactionSubmitPermission ??
             true;
+        this.productAccount = options?.productAccount;
     }
 
     async connect(signal?: AbortSignal): Promise<Result<SignerAccount[], SignerError>> {
@@ -438,27 +458,46 @@ export class HostProvider implements SignerProvider {
         const provider = sdk.createAccountsProvider();
         this.accountsProvider = provider;
 
-        // Step 3: Fetch non-product accounts
-        let rawAccounts: RawAccount[];
-        try {
-            rawAccounts = (await provider.getLegacyAccounts().match(
-                (accounts) => accounts,
-                (error) => {
-                    throw new Error(`Host rejected account request: ${formatError(error)}`);
-                },
-            )) as RawAccount[];
-        } catch (cause) {
-            log.error("failed to get accounts from host", { cause });
-            return err(
-                new HostRejectedError(
-                    cause instanceof Error ? cause.message : "Failed to get accounts from host",
-                ),
+        // Step 3: Fetch accounts.
+        //
+        // When `productAccount` is configured, skip the legacy fetch entirely
+        // and return a single product account. Product-account-only apps
+        // (no wallet picker) often run against hosts that have no legacy
+        // accounts to surface — calling `getLegacyAccounts()` there returns
+        // an empty list and the connect would fail with `NoAccountsError`.
+        let signerAccounts: SignerAccount[];
+        if (this.productAccount) {
+            const accountResult = await this.fetchProductSignerAccount(
+                provider,
+                this.productAccount.dotNsIdentifier,
+                this.productAccount.derivationIndex ?? 0,
             );
-        }
+            if (!accountResult.ok) return accountResult;
+            signerAccounts = [accountResult.value];
+        } else {
+            let rawAccounts: RawAccount[];
+            try {
+                rawAccounts = (await provider.getLegacyAccounts().match(
+                    (accounts) => accounts,
+                    (error) => {
+                        throw new Error(`Host rejected account request: ${formatError(error)}`);
+                    },
+                )) as RawAccount[];
+            } catch (cause) {
+                log.error("failed to get accounts from host", { cause });
+                return err(
+                    new HostRejectedError(
+                        cause instanceof Error ? cause.message : "Failed to get accounts from host",
+                    ),
+                );
+            }
 
-        if (rawAccounts.length === 0) {
-            log.warn("host returned no accounts");
-            return err(new NoAccountsError("host"));
+            if (rawAccounts.length === 0) {
+                log.warn("host returned no accounts");
+                return err(new NoAccountsError("host"));
+            }
+
+            signerAccounts = this.mapAccounts(rawAccounts);
         }
 
         // Step 4: Request ChainSubmit permission up-front.
@@ -476,10 +515,11 @@ export class HostProvider implements SignerProvider {
         // will surface a clear error if permission is missing.
         //
         // The legal v1 RemotePermission variants per
-        // `@novasamatech/host-api@0.7.7` are: Remote, WebRTC, ChainSubmit,
+        // `@novasamatech/host-api@0.8.0` are: Remote, WebRtc, ChainSubmit,
         // PreimageSubmit, StatementSubmit. ChainSubmit is the chain-tx
         // permission (was named TransactionSubmit in earlier host-api
-        // revisions; renamed in 0.7).
+        // revisions; renamed in 0.7). `WebRtc` was spelled `WebRTC` before
+        // 0.8.
         if (this.requestChainSubmitPermission && sdk.hostApi) {
             try {
                 const hostApiEnum = await this.loadHostApiEnum();
@@ -502,9 +542,7 @@ export class HostProvider implements SignerProvider {
             }
         }
 
-        // Step 5: Map to SignerAccount[]
-        const accounts = this.mapAccounts(rawAccounts);
-        log.info("host connected", { accounts: accounts.length });
+        log.info("host connected", { accounts: signerAccounts.length });
 
         // Step 6: Subscribe to connection status
         const sub = provider.subscribeAccountConnectionStatus((status) => {
@@ -516,7 +554,43 @@ export class HostProvider implements SignerProvider {
         });
         this.statusCleanup = typeof sub === "function" ? sub : () => sub.unsubscribe();
 
-        return ok(accounts);
+        return ok(signerAccounts);
+    }
+
+    private async fetchProductSignerAccount(
+        provider: AccountsProvider,
+        dotNsIdentifier: string,
+        derivationIndex: number,
+    ): Promise<Result<SignerAccount, SignerError>> {
+        // Run the account fetch and the best-effort username fetch in
+        // parallel — they're independent host RPCs. `getUserId` failures
+        // (NotConnected, PermissionDenied, codec drift) resolve to `null`
+        // so they never abort connect; the account name falls back to
+        // whatever `getProductAccount` returned (typically also null,
+        // since product accounts are nameless on the host side).
+        const fetchUsername = async (): Promise<string | null> => {
+            try {
+                return await provider.getUserId().match(
+                    (result) => result.primaryUsername,
+                    (error) => {
+                        log.debug("getUserId failed; product account name stays null", {
+                            error: formatError(error),
+                        });
+                        return null as string | null;
+                    },
+                );
+            } catch (cause) {
+                log.debug("getUserId threw; product account name stays null", { cause });
+                return null;
+            }
+        };
+        const [accountResult, primaryUsername] = await Promise.all([
+            this.getProductAccount(dotNsIdentifier, derivationIndex),
+            fetchUsername(),
+        ]);
+        if (!accountResult.ok) return accountResult;
+        const account = accountResult.value;
+        return ok({ ...account, name: account.name ?? primaryUsername });
     }
 
     private mapAccounts(rawAccounts: ReadonlyArray<RawAccount>): SignerAccount[] {
@@ -601,6 +675,7 @@ if (import.meta.vitest) {
             accounts?: RawAccountTest[];
             shouldReject?: boolean;
             error?: unknown;
+            primaryUsername?: string;
         } = {},
     ) {
         const accounts = options.accounts ?? [];
@@ -654,6 +729,17 @@ if (import.meta.vitest) {
                 },
             }),
             subscribeAccountConnectionStatus: vi.fn().mockReturnValue(() => {}),
+            getUserId: vi.fn().mockReturnValue({
+                match: async (
+                    onOk: (v: { primaryUsername: string }) => unknown,
+                    onErr: (e: unknown) => unknown,
+                ) => {
+                    if (shouldReject) {
+                        return onErr(options.error ?? "Unknown");
+                    }
+                    return onOk({ primaryUsername: options.primaryUsername ?? "" });
+                },
+            }),
         };
     }
 
@@ -812,6 +898,93 @@ if (import.meta.vitest) {
             expect(typeof unsub).toBe("function");
             unsub();
         });
+
+        test("productAccount option returns the derived account, populates name via getUserId, and skips the legacy fetch", async () => {
+            const productPubkey = new Uint8Array(32).fill(0xcc);
+            const mockProvider = createMockProvider({
+                accounts: [{ publicKey: productPubkey, name: undefined }],
+                primaryUsername: "alice",
+            });
+            const provider = new HostProvider({
+                maxRetries: 1,
+                loadSdk: () => Promise.resolve(createMockSdk(mockProvider)),
+                productAccount: { dotNsIdentifier: "myapp.dot", derivationIndex: 0 },
+            });
+            const result = await provider.connect();
+
+            expect(result.ok).toBe(true);
+            if (result.ok) {
+                expect(result.value).toHaveLength(1);
+                expect(result.value[0].publicKey).toEqual(productPubkey);
+                expect(result.value[0].source).toBe("host");
+                expect(result.value[0].name).toBe("alice");
+                result.value[0].getSigner();
+                expect(mockProvider.getProductAccountSigner).toHaveBeenLastCalledWith(
+                    expect.objectContaining({
+                        dotNsIdentifier: "myapp.dot",
+                        derivationIndex: 0,
+                    }),
+                    "createTransaction",
+                );
+            }
+            expect(mockProvider.getProductAccount).toHaveBeenCalledWith("myapp.dot", 0);
+            expect(mockProvider.getUserId).toHaveBeenCalled();
+            expect(mockProvider.getLegacyAccounts).not.toHaveBeenCalled();
+        });
+
+        test("productAccount option survives getUserId failure (name stays null, connect still succeeds)", async () => {
+            const productPubkey = new Uint8Array(32).fill(0xee);
+            const mockProvider = createMockProvider({
+                accounts: [{ publicKey: productPubkey, name: undefined }],
+            });
+            // Force getUserId to reject — connect must still succeed with name=null.
+            mockProvider.getUserId.mockReturnValue({
+                match: async (
+                    _onOk: (v: { primaryUsername: string }) => unknown,
+                    onErr: (e: unknown) => unknown,
+                ) => onErr({ tag: "v1", value: { tag: "GetUserIdErr::PermissionDenied" } }),
+            });
+            const provider = new HostProvider({
+                maxRetries: 1,
+                loadSdk: () => Promise.resolve(createMockSdk(mockProvider)),
+                productAccount: { dotNsIdentifier: "myapp.dot" },
+            });
+            const result = await provider.connect();
+
+            expect(result.ok).toBe(true);
+            if (result.ok) {
+                expect(result.value[0].name).toBeNull();
+            }
+        });
+
+        test("productAccount option succeeds when host has no legacy accounts (regression: signer 0.5.0 NoAccountsError)", async () => {
+            // Without the option, this scenario returned `err(NoAccountsError)`
+            // before any product-account fetch could happen — breaking every
+            // product-only app whose host doesn't surface legacy accounts.
+            const productPubkey = new Uint8Array(32).fill(0xdd);
+            const mockProvider = createMockProvider({
+                accounts: [{ publicKey: productPubkey, name: undefined }],
+            });
+            // Force the legacy path to look empty if it were ever consulted.
+            mockProvider.getLegacyAccounts.mockReturnValue({
+                match: async (
+                    onOk: (v: RawAccountTest[]) => unknown,
+                    _onErr: (e: unknown) => unknown,
+                ) => onOk([]),
+            });
+            const provider = new HostProvider({
+                maxRetries: 1,
+                loadSdk: () => Promise.resolve(createMockSdk(mockProvider)),
+                productAccount: { dotNsIdentifier: "playground.dot" },
+            });
+            const result = await provider.connect();
+
+            expect(result.ok).toBe(true);
+            if (result.ok) {
+                expect(result.value).toHaveLength(1);
+                expect(result.value[0].publicKey).toEqual(productPubkey);
+            }
+        });
     });
 
     describe("ChainSubmit permission request", () => {

package/src/providers/index.ts

@@ -1,3 +1,5 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
 // Provider interface
 export type { SignerProvider, Unsubscribe } from "./types.js";
 

package/src/providers/types.ts

@@ -1,3 +1,5 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
 import type { SignerError } from "../errors.js";
 import type { ConnectionStatus, ProviderType, Result, SignerAccount } from "../types.js";
 

package/src/retry.ts

@@ -1,3 +1,5 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
 /**
  * Result-based retry with exponential backoff for signer connection attempts.
  *

package/src/signer-manager.ts

@@ -1,3 +1,5 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
 import type { PolkadotSigner } from "polkadot-api";
 
 import { createLogger } from "@parity/product-sdk-logger";

package/src/sleep.ts

@@ -1,3 +1,5 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
 /**
  * Sleep for a given duration, cancellable via AbortSignal.
  *

package/src/types.ts

@@ -1,3 +1,5 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
 import type { PolkadotSigner } from "polkadot-api";
 
 import type { SS58String } from "@parity/product-sdk-address";