@parity/product-sdk-signer 0.7.0 → 0.8.1

package/dist/index.d.ts

@@ -257,6 +257,22 @@ interface HostProviderOptions {
     maxRetries?: number;
     /** Initial retry delay in ms. Default: 500 */
     retryDelay?: number;
+    /**
+     * Dapp identifier the SDK falls back to when {@link productAccount} is
+     * not set, so `connect()` can still surface a usable account on hosts
+     * that don't enumerate legacy accounts.
+     *
+     * The value is treated as a dotNS identifier (`.dot` is appended if
+     * missing) and routed through `getProductAccount(dappName, 0)`. If the
+     * host rejects the derivation (e.g. the identifier isn't registered),
+     * `connect()` resolves with an empty accounts list rather than
+     * throwing — consumers can still drive the explicit signing paths
+     * (`signMessageWithDotNsIdentity`, `getLegacyAccountSigner`).
+     *
+     * Wired through from `SignerManager` automatically; only set directly
+     * when instantiating `HostProvider` outside the manager.
+     */
+    dappName?: string;
     /**
      * Custom SDK loader. Defaults to `import("@novasamatech/host-api-wrapper")`.
      * Override this for testing or custom SDK setups.
@@ -357,7 +373,6 @@ interface NeverthrowResultAsync<T, E> {
 }
 /** @internal */
 interface AccountsProvider {
-    getLegacyAccounts: () => NeverthrowResultAsync<RawAccount[], unknown>;
     getLegacyAccountSigner: (account: ProductAccount) => polkadot_api.PolkadotSigner;
     getProductAccount: (dotNsIdentifier: string, derivationIndex?: number) => NeverthrowResultAsync<RawAccount, unknown>;
     getProductAccountSigner: (account: ProductAccount, signerType?: "signPayload" | "createTransaction") => polkadot_api.PolkadotSigner;
@@ -426,6 +441,7 @@ declare class HostProvider implements SignerProvider {
     private readonly loadHostApiEnum;
     private readonly requestChainSubmitPermission;
     private readonly productAccount;
+    private readonly dappName;
     private accountsProvider;
     private statusCleanup;
     private statusListeners;
@@ -494,7 +510,6 @@ declare class HostProvider implements SignerProvider {
     createRingVRFProof(dotNsIdentifier: string, derivationIndex: number, location: RingLocation, message: Uint8Array): Promise<Result<Uint8Array, SignerError>>;
     private tryConnect;
     private fetchProductSignerAccount;
-    private mapAccounts;
 }
 
 /**
@@ -643,6 +658,17 @@ declare class SignerManager {
      * Returns a SIGNING_FAILED error if no account is selected or signing fails.
      */
     signRaw(data: Uint8Array): Promise<Result<Uint8Array, SignerError>>;
+    /**
+     * Fetch the connected user's host identity.
+     *
+     * This uses the Host API identity permission path and is only available
+     * when connected through the host provider. The primary username can be
+     * used by higher-level helpers that need to bind an action to the user's
+     * DotNS / people username.
+     */
+    getUserId(): Promise<Result<{
+        primaryUsername: string;
+    }, SignerError>>;
     /**
      * Get an app-scoped product account from the host.
      *

package/dist/index.js

@@ -196,6 +196,7 @@ var HostProvider = class {
   loadHostApiEnum;
   requestChainSubmitPermission;
   productAccount;
+  dappName;
   accountsProvider = null;
   statusCleanup = null;
   statusListeners = /* @__PURE__ */ new Set();
@@ -208,6 +209,7 @@ var HostProvider = class {
     this.loadHostApiEnum = options?.loadHostApiEnum ?? defaultLoadHostApiEnum;
     this.requestChainSubmitPermission = options?.requestChainSubmitPermission ?? options?.requestTransactionSubmitPermission ?? true;
     this.productAccount = options?.productAccount;
+    this.dappName = options?.dappName;
   }
   async connect(signal) {
     log2.debug("attempting Host API connection");
@@ -446,36 +448,31 @@ var HostProvider = class {
       );
       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)}`);
+    } else if (this.dappName) {
+      const dotNsIdentifier = this.dappName.endsWith(".dot") ? this.dappName : `${this.dappName}.dot`;
+      const accountResult = await this.fetchProductSignerAccount(
+        provider,
+        dotNsIdentifier,
+        0,
+        true
+      );
+      if (!accountResult.ok) {
+        log2.warn(
+          "host could not derive a product account for dappName; resolving with empty accounts",
+          {
+            dotNsIdentifier,
+            error: accountResult.error.message
           }
         );
-      } catch (cause) {
-        if (cause instanceof Error && /environment is not correct/i.test(cause.message)) {
-          log2.warn("not inside a host container (detected at getLegacyAccounts)");
-          return err(
-            new HostUnavailableError(
-              "Host API is not available: not running inside a Polkadot host container. Open this app inside Polkadot Desktop or the Polkadot Mobile WebView, or pick a non-host signer provider (e.g. dev accounts)."
-            )
-          );
-        }
-        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 = [];
+      } else {
+        signerAccounts = [accountResult.value];
       }
-      signerAccounts = this.mapAccounts(rawAccounts);
+    } else {
+      log2.warn(
+        "no productAccount or dappName configured; resolving connect() with empty accounts"
+      );
+      signerAccounts = [];
     }
     if (this.requestChainSubmitPermission && sdk.hostApi) {
       try {
@@ -535,29 +532,6 @@ var HostProvider = class {
     const account = accountResult.value;
     return ok({ ...account, name: account.name ?? primaryUsername });
   }
-  mapAccounts(rawAccounts) {
-    return rawAccounts.map((raw) => {
-      const address = ss58Encode(raw.publicKey, this.ss58Prefix);
-      const h160Address = deriveH160(raw.publicKey);
-      return {
-        address,
-        h160Address,
-        publicKey: raw.publicKey,
-        name: raw.name ?? null,
-        source: "host",
-        getSigner: () => {
-          if (!this.accountsProvider) {
-            throw new Error("Host provider is disconnected");
-          }
-          return this.accountsProvider.getLegacyAccountSigner({
-            dotNsIdentifier: "",
-            derivationIndex: 0,
-            publicKey: raw.publicKey
-          });
-        }
-      };
-    });
-  }
 };
 function formatError(error) {
   if (!error || typeof error !== "object") return String(error);
@@ -775,6 +749,24 @@ var SignerManager = class {
     }
   }
   // ── Host-only: Product Account API ─────────────────────────────
+  /**
+   * Fetch the connected user's host identity.
+   *
+   * This uses the Host API identity permission path and is only available
+   * when connected through the host provider. The primary username can be
+   * used by higher-level helpers that need to bind an action to the user's
+   * DotNS / people username.
+   */
+  async getUserId() {
+    if (this.isDestroyed) return err(new DestroyedError());
+    const host = this.getHostProvider();
+    if (!host) {
+      return err(
+        new HostUnavailableError("User identity requires a host provider connection")
+      );
+    }
+    return host.getUserId();
+  }
   /**
    * Get an app-scoped product account from the host.
    *
@@ -904,7 +896,8 @@ var SignerManager = class {
         return new HostProvider({
           ss58Prefix: this.ss58Prefix,
           maxRetries: this.maxRetries,
-          retryDelay: 500
+          retryDelay: 500,
+          dappName: this.dappName
         });
       case "dev":
         return new DevProvider({