@parity/product-sdk-signer 0.4.0 → 0.6.0

package/dist/index.d.ts

@@ -272,6 +272,21 @@ 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;
+    };
 }
 /**
  * A product account — an app-scoped derived account managed by the host wallet.
@@ -324,6 +339,9 @@ interface AccountsProvider {
     getProductAccount: (dotNsIdentifier: string, derivationIndex?: number) => NeverthrowResultAsync<RawAccount, unknown>;
     getProductAccountSigner: (account: ProductAccount, signerType?: "signPayload" | "createTransaction") => polkadot_api.PolkadotSigner;
     getProductAccountAlias: (dotNsIdentifier: string, derivationIndex?: number) => NeverthrowResultAsync<ContextualAlias, unknown>;
+    getUserId: () => NeverthrowResultAsync<{
+        primaryUsername: string;
+    }, unknown>;
     createRingVRFProof: (dotNsIdentifier: string, derivationIndex: number, location: unknown, message: Uint8Array) => NeverthrowResultAsync<Uint8Array, unknown>;
     subscribeAccountConnectionStatus: (callback: (status: string) => void) => {
         unsubscribe: () => void;
@@ -369,6 +387,7 @@ declare class HostProvider implements SignerProvider {
     private readonly loadSdk;
     private readonly loadHostApiEnum;
     private readonly requestChainSubmitPermission;
+    private readonly productAccount;
     private accountsProvider;
     private statusCleanup;
     private statusListeners;
@@ -420,6 +439,7 @@ declare class HostProvider implements SignerProvider {
      */
     createRingVRFProof(dotNsIdentifier: string, derivationIndex: number, location: RingLocation, message: Uint8Array): Promise<Result<Uint8Array, SignerError>>;
     private tryConnect;
+    private fetchProductSignerAccount;
     private mapAccounts;
 }
 

package/dist/index.js

@@ -195,6 +195,7 @@ var HostProvider = class {
   loadSdk;
   loadHostApiEnum;
   requestChainSubmitPermission;
+  productAccount;
   accountsProvider = null;
   statusCleanup = null;
   statusListeners = /* @__PURE__ */ new Set();
@@ -206,6 +207,7 @@ var HostProvider = class {
     this.loadSdk = options?.loadSdk ?? defaultLoadSdk;
     this.loadHostApiEnum = options?.loadHostApiEnum ?? defaultLoadHostApiEnum;
     this.requestChainSubmitPermission = options?.requestChainSubmitPermission ?? options?.requestTransactionSubmitPermission ?? true;
+    this.productAccount = options?.productAccount;
   }
   async connect(signal) {
     log2.debug("attempting Host API connection");
@@ -392,25 +394,37 @@ var HostProvider = class {
     }
     const provider = sdk.createAccountsProvider();
     this.accountsProvider = provider;
-    let rawAccounts;
-    try {
-      rawAccounts = await provider.getLegacyAccounts().match(
-        (accounts2) => accounts2,
-        (error) => {
-          throw new Error(`Host rejected account request: ${formatError(error)}`);
-        }
-      );
-    } catch (cause) {
-      log2.error("failed to get accounts from host", { cause });
-      return err(
-        new HostRejectedError(
-          cause instanceof Error ? cause.message : "Failed to get accounts from host"
-        )
+    let signerAccounts;
+    if (this.productAccount) {
+      const accountResult = await this.fetchProductSignerAccount(
+        provider,
+        this.productAccount.dotNsIdentifier,
+        this.productAccount.derivationIndex ?? 0
       );
-    }
-    if (rawAccounts.length === 0) {
-      log2.warn("host returned no accounts");
-      return err(new NoAccountsError("host"));
+      if (!accountResult.ok) return accountResult;
+      signerAccounts = [accountResult.value];
+    } else {
+      let rawAccounts;
+      try {
+        rawAccounts = await provider.getLegacyAccounts().match(
+          (accounts) => accounts,
+          (error) => {
+            throw new Error(`Host rejected account request: ${formatError(error)}`);
+          }
+        );
+      } catch (cause) {
+        log2.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) {
+        log2.warn("host returned no accounts");
+        return err(new NoAccountsError("host"));
+      }
+      signerAccounts = this.mapAccounts(rawAccounts);
     }
     if (this.requestChainSubmitPermission && sdk.hostApi) {
       try {
@@ -433,8 +447,7 @@ var HostProvider = class {
         log2.warn("failed to request ChainSubmit permission", { cause });
       }
     }
-    const accounts = this.mapAccounts(rawAccounts);
-    log2.info("host connected", { accounts: accounts.length });
+    log2.info("host connected", { accounts: signerAccounts.length });
     const sub = provider.subscribeAccountConnectionStatus((status) => {
       const mapped = status === "connected" ? "connected" : "disconnected";
       log2.debug("host status changed", { status: mapped });
@@ -443,7 +456,32 @@ var HostProvider = class {
       }
     });
     this.statusCleanup = typeof sub === "function" ? sub : () => sub.unsubscribe();
-    return ok(accounts);
+    return ok(signerAccounts);
+  }
+  async fetchProductSignerAccount(provider, dotNsIdentifier, derivationIndex) {
+    const fetchUsername = async () => {
+      try {
+        return await provider.getUserId().match(
+          (result) => result.primaryUsername,
+          (error) => {
+            log2.debug("getUserId failed; product account name stays null", {
+              error: formatError(error)
+            });
+            return null;
+          }
+        );
+      } catch (cause) {
+        log2.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 });
   }
   mapAccounts(rawAccounts) {
     return rawAccounts.map((raw) => {