@parity/product-sdk-signer 0.8.2 → 0.9.0

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import * as polkadot_api from 'polkadot-api';
 import { PolkadotSigner } from 'polkadot-api';
 import { SS58String } from '@parity/product-sdk-address';
-import { AllocatableResource, AllocationOutcome } from '@parity/product-sdk-host';
+import { AllocatableResource, AllocationOutcome, RemotePermission } from '@parity/product-sdk-host';
 
 /** Function that unsubscribes a listener when called. */
 type Unsubscribe = () => void;
@@ -151,10 +151,11 @@ interface SignerManagerOptions {
      * plus an `AbortSignal` that fires if the user disconnects or
      * destroys the manager mid-flight.
      *
-     * `requestResourceAllocation` throws on failure (matches the
-     * `@parity/product-sdk-host` export of the same name); errors thrown
-     * from `onConnect` are logged but do not affect the connected state —
-     * the next reconnect retries.
+     * `requestResourceAllocation` throws on failure (it adapts the
+     * `Result`-returning `@parity/product-sdk-host` export of the same name,
+     * re-throwing the typed error on the `err` channel); errors thrown from
+     * `onConnect` are logged but do not affect the connected state — the next
+     * reconnect retries.
      *
      * @example
      * ```ts
@@ -165,7 +166,7 @@ interface SignerManagerOptions {
      *         { tag: "AutoSigning", value: undefined },
      *       ]);
      *       if (signal.aborted) return;
-     *       if (outcomes.some((o) => o.tag !== "Allocated")) {
+     *       if (outcomes.some((o) => o !== "Allocated")) {
      *         logWarning("partial permissions", outcomes);
      *       }
      *     } catch (cause) {
@@ -186,9 +187,10 @@ interface ConnectContext {
      */
     signal: AbortSignal;
     /**
-     * Request a batch of host resource allocations. Bound shorthand for
-     * `requestResourceAllocation` from `@parity/product-sdk-host` —
-     * throws on failure, returns the unwrapped outcomes on success.
+     * Request a batch of host resource allocations. Adapts
+     * `requestResourceAllocation` from `@parity/product-sdk-host` (which returns
+     * a `Result`) to this throwing contract — returns the unwrapped outcomes on
+     * success, throws the typed host error on failure.
      */
     requestResourceAllocation: (resources: AllocatableResource[]) => Promise<AllocationOutcome[]>;
 }
@@ -206,7 +208,8 @@ declare class SignerError extends Error {
  * - The app is loaded outside a Polkadot host container (a regular browser tab
  *   under `npm run dev`, no iframe, no WebView). This is the dominant case
  *   during local development.
- * - The optional `@novasamatech/host-api(-wrapper)` peer is not installed.
+ * - The host environment is detected but the TruAPI transport can't be reached
+ *   (no injected message port / unresolvable host origin).
  *
  * Branch with `instanceof HostUnavailableError` to surface a "open this app
  * in a Polkadot host, or pick a dev provider" message to the user.
@@ -274,17 +277,19 @@ interface HostProviderOptions {
      */
     dappName?: string;
     /**
-     * Custom SDK loader. Defaults to `import("@novasamatech/host-api-wrapper")`.
-     * Override this for testing or custom SDK setups.
+     * Custom accounts-provider loader. Defaults to `@parity/product-sdk-host`'s
+     * `getAccountsProvider`, which returns `null` outside a host container.
+     * Override for testing or custom host setups.
      * @internal
      */
-    loadSdk?: () => Promise<ProductSdkModule>;
+    loadAccountsProvider?: () => Promise<AccountsProvider | null>;
     /**
-     * Custom loader for `@novasamatech/host-api` (used to construct the
-     * `ChainSubmit` permission request). Defaults to dynamic import.
+     * Custom `ChainSubmit` permission requester. Defaults to a thin adapter over
+     * `@parity/product-sdk-host`'s `requestPermission` that unwraps its `Result`
+     * (throwing the typed error on the `err` channel). Override for testing.
      * @internal
      */
-    loadHostApiEnum?: () => Promise<HostApiEnumHelper>;
+    requestChainSubmitPermissionFn?: (permission: RemotePermission) => Promise<boolean>;
     /**
      * Whether to request the host's `ChainSubmit` permission after a
      * successful `connect()`. Without this, subsequent signing requests are
@@ -304,7 +309,7 @@ interface HostProviderOptions {
      * `dotNsIdentifier`, skipping the legacy fetch entirely. For apps
      * that sign exclusively with a per-dapp derived account.
      *
-     * Signing is pinned to `createTransaction` (see PR #96).
+     * Signing goes through the host's `createTransaction` path (see PR #96).
      */
     productAccount?: {
         /** App identifier (e.g., `"playground.dot"`). */
@@ -373,9 +378,12 @@ interface NeverthrowResultAsync<T, E> {
 }
 /** @internal */
 interface AccountsProvider {
-    getLegacyAccountSigner: (account: ProductAccount) => polkadot_api.PolkadotSigner;
+    getLegacyAccounts: () => NeverthrowResultAsync<RawAccount[], unknown>;
+    getLegacyAccountSigner: (account: {
+        publicKey: Uint8Array;
+    }) => polkadot_api.PolkadotSigner;
     getProductAccount: (dotNsIdentifier: string, derivationIndex?: number) => NeverthrowResultAsync<RawAccount, unknown>;
-    getProductAccountSigner: (account: ProductAccount, signerType?: "signPayload" | "createTransaction") => polkadot_api.PolkadotSigner;
+    getProductAccountSigner: (account: ProductAccount) => polkadot_api.PolkadotSigner;
     getProductAccountAlias: (dotNsIdentifier: string, derivationIndex?: number) => NeverthrowResultAsync<ContextualAlias, unknown>;
     getUserId: () => NeverthrowResultAsync<{
         primaryUsername: string;
@@ -385,49 +393,14 @@ interface AccountsProvider {
         unsubscribe: () => void;
     } | (() => void);
 }
-/** @internal */
-interface HostApiPermissionBridge {
-    /**
-     * Request a Host API permission. Product-sdk's `hostApi.permission(...)`
-     * takes a tagged enum like `enumValue("v1", { tag: "TransactionSubmit" })`
-     * and returns a neverthrow ResultAsync.
-     */
-    permission: (request: unknown) => NeverthrowResultAsync<unknown, unknown>;
-}
-/** @internal */
-interface HostApiEnumHelper {
-    enumValue: (version: string, value: {
-        tag: string;
-        value?: unknown;
-    }) => unknown;
-}
-/** @internal */
-interface ProductSdkModule {
-    createAccountsProvider: () => AccountsProvider;
-    /** Present from product-sdk ≥ 0.6; used to request TransactionSubmit. */
-    hostApi?: HostApiPermissionBridge;
-    /**
-     * `sandboxTransport.isCorrectEnvironment()` returns `false` when the app
-     * is loaded outside a Polkadot host container (e.g. a regular browser
-     * tab). Calling `getLegacyAccounts()` / `getProductAccount()` in that
-     * state surfaces the upstream `Environment is not correct` exception,
-     * so we pre-check during `connect()` and raise a specific
-     * {@link HostUnavailableError} with actionable guidance instead.
-     */
-    sandboxTransport?: {
-        isCorrectEnvironment(): boolean;
-    };
-}
 /**
  * Provider for the Host API (Polkadot Desktop / Android).
  *
- * Dynamically imports `@novasamatech/host-api-wrapper` at runtime. Apps running
- * outside a host container — e.g. a plain browser tab during `npm run dev` —
- * resolve to {@link HostUnavailableError} with guidance on what to do (open
- * the app inside a Polkadot host or pick a non-host provider). The check uses
- * the wrapper's `sandboxTransport.isCorrectEnvironment()` predicate and runs
- * before any host RPC call, so the user never sees the upstream
- * `Environment is not correct` exception leaking through.
+ * Backed by `@parity/product-sdk-host`'s `getAccountsProvider`, which talks to
+ * the host over `@parity/truapi`. Apps running outside a host container — e.g.
+ * a plain browser tab during `npm run dev` — get a `HOST_UNAVAILABLE` error
+ * (the provider resolves to `null`) with actionable guidance, surfaced before
+ * any host RPC call.
  *
  * Supports both non-product accounts (user's external wallets) and product
  * accounts (app-scoped derived accounts managed by the host).
@@ -437,8 +410,8 @@ declare class HostProvider implements SignerProvider {
     private readonly ss58Prefix;
     private readonly maxRetries;
     private readonly retryDelay;
-    private readonly loadSdk;
-    private readonly loadHostApiEnum;
+    private readonly loadAccountsProvider;
+    private readonly requestChainSubmitPermissionFn;
     private readonly requestChainSubmitPermission;
     private readonly productAccount;
     private readonly dappName;
@@ -467,11 +440,9 @@ declare class HostProvider implements SignerProvider {
      * Convenience method for when you already have the product account details.
      * Requires a prior successful `connect()` call.
      *
-     * Routing is pinned to `signerType: "createTransaction"` via
-     * {@link PRODUCT_SIGNER_TYPE} so unknown signed extensions (e.g. `AsPgas`
-     * on Paseo Next) are forwarded to the host as opaque bytes for
-     * metadata-driven decoding, rather than going through the PJS bridge
-     * that throws on unknown extensions.
+     * Signing routes through the host's `createTransaction` path, so unknown
+     * signed extensions (e.g. `AsPgas` on Paseo Next) are forwarded to the host
+     * as opaque bytes for metadata-driven decoding.
      */
     getProductAccountSigner(account: ProductAccount): polkadot_api.PolkadotSigner;
     /**

package/dist/index.js

@@ -1,5 +1,5 @@
 import { createLogger } from '@parity/product-sdk-logger';
-import { requestResourceAllocation, getHostLocalStorage } from '@parity/product-sdk-host';
+import { requestResourceAllocation, getAccountsProvider, requestPermission, getHostLocalStorage } from '@parity/product-sdk-host';
 import { seedToAccount } from '@parity/product-sdk-keys';
 import { ss58Encode, deriveH160 } from '@parity/product-sdk-address';
 
@@ -180,20 +180,21 @@ async function withRetry(fn, options) {
 
 // src/providers/host.ts
 var log2 = createLogger("signer:host");
-var PRODUCT_SIGNER_TYPE = "createTransaction";
-async function defaultLoadSdk() {
-  return await import('@novasamatech/host-api-wrapper');
+async function defaultLoadAccountsProvider() {
+  return await getAccountsProvider();
 }
-async function defaultLoadHostApiEnum() {
-  return await import('@novasamatech/host-api');
+async function defaultRequestChainSubmitPermission(permission) {
+  const result = await requestPermission(permission);
+  if (!result.ok) throw result.error;
+  return result.value;
 }
 var HostProvider = class {
   type = "host";
   ss58Prefix;
   maxRetries;
   retryDelay;
-  loadSdk;
-  loadHostApiEnum;
+  loadAccountsProvider;
+  requestChainSubmitPermissionFn;
   requestChainSubmitPermission;
   productAccount;
   dappName;
@@ -205,8 +206,8 @@ var HostProvider = class {
     this.ss58Prefix = options?.ss58Prefix ?? 42;
     this.maxRetries = options?.maxRetries ?? 3;
     this.retryDelay = options?.retryDelay ?? 500;
-    this.loadSdk = options?.loadSdk ?? defaultLoadSdk;
-    this.loadHostApiEnum = options?.loadHostApiEnum ?? defaultLoadHostApiEnum;
+    this.loadAccountsProvider = options?.loadAccountsProvider ?? defaultLoadAccountsProvider;
+    this.requestChainSubmitPermissionFn = options?.requestChainSubmitPermissionFn ?? defaultRequestChainSubmitPermission;
     this.requestChainSubmitPermission = options?.requestChainSubmitPermission ?? options?.requestTransactionSubmitPermission ?? true;
     this.productAccount = options?.productAccount;
     this.dappName = options?.dappName;
@@ -288,10 +289,7 @@ var HostProvider = class {
           if (!this.accountsProvider) {
             throw new Error("Host provider is disconnected");
           }
-          return this.accountsProvider.getProductAccountSigner(
-            productAccount,
-            PRODUCT_SIGNER_TYPE
-          );
+          return this.accountsProvider.getProductAccountSigner(productAccount);
         }
       });
     } catch (cause) {
@@ -309,17 +307,15 @@ var HostProvider = class {
    * Convenience method for when you already have the product account details.
    * Requires a prior successful `connect()` call.
    *
-   * Routing is pinned to `signerType: "createTransaction"` via
-   * {@link PRODUCT_SIGNER_TYPE} so unknown signed extensions (e.g. `AsPgas`
-   * on Paseo Next) are forwarded to the host as opaque bytes for
-   * metadata-driven decoding, rather than going through the PJS bridge
-   * that throws on unknown extensions.
+   * Signing routes through the host's `createTransaction` path, so unknown
+   * signed extensions (e.g. `AsPgas` on Paseo Next) are forwarded to the host
+   * as opaque bytes for metadata-driven decoding.
    */
   getProductAccountSigner(account) {
     if (!this.accountsProvider) {
       throw new Error("Host provider is not connected");
     }
-    return this.accountsProvider.getProductAccountSigner(account, PRODUCT_SIGNER_TYPE);
+    return this.accountsProvider.getProductAccountSigner(account);
   }
   /**
    * Get a contextual alias for a product account via Ring VRF.
@@ -417,18 +413,18 @@ var HostProvider = class {
   }
   // ── Private ──────────────────────────────────────────────────────
   async tryConnect() {
-    let sdk;
+    let provider;
     try {
-      sdk = await this.loadSdk();
+      provider = await this.loadAccountsProvider();
     } catch (cause) {
-      log2.warn("product-sdk not available", { cause });
+      log2.warn("host accounts provider unavailable", { cause });
       return err(
         new HostUnavailableError(
-          cause instanceof Error ? `product-sdk import failed: ${cause.message}` : "product-sdk is not installed"
+          cause instanceof Error ? `host accounts provider failed: ${cause.message}` : "host accounts provider is unavailable"
         )
       );
     }
-    if (sdk.sandboxTransport && !sdk.sandboxTransport.isCorrectEnvironment()) {
+    if (!provider) {
       log2.warn("not inside a host container \u2014 Host API unavailable");
       return err(
         new HostUnavailableError(
@@ -436,7 +432,6 @@ var HostProvider = class {
         )
       );
     }
-    const provider = sdk.createAccountsProvider();
     this.accountsProvider = provider;
     let signerAccounts;
     if (this.productAccount) {
@@ -474,30 +469,20 @@ var HostProvider = class {
       );
       signerAccounts = [];
     }
-    if (this.requestChainSubmitPermission && sdk.hostApi) {
+    if (this.requestChainSubmitPermission) {
       try {
-        const hostApiEnum = await this.loadHostApiEnum();
-        const request = hostApiEnum.enumValue("v1", {
+        const granted = await this.requestChainSubmitPermissionFn({
           tag: "ChainSubmit",
           value: void 0
         });
-        await sdk.hostApi.permission(request).match(
-          () => {
-            log2.debug("ChainSubmit permission granted");
-          },
-          (error) => {
-            log2.warn("ChainSubmit permission rejected by host", {
-              error: formatError(error)
-            });
-          }
-        );
+        log2.debug("ChainSubmit permission result", { granted });
       } catch (cause) {
         log2.warn("failed to request ChainSubmit permission", { cause });
       }
     }
     log2.info("host connected", { accounts: signerAccounts.length });
     const sub = provider.subscribeAccountConnectionStatus((status) => {
-      const mapped = status === "connected" ? "connected" : "disconnected";
+      const mapped = String(status).toLowerCase() === "connected" ? "connected" : "disconnected";
       log2.debug("host status changed", { status: mapped });
       for (const listener of this.statusListeners) {
         listener(mapped);
@@ -536,7 +521,11 @@ var HostProvider = class {
 function formatError(error) {
   if (!error || typeof error !== "object") return String(error);
   const e = error;
-  if (!("tag" in e)) return String(error);
+  if (!("tag" in e)) {
+    if (typeof e.reason === "string") return e.reason;
+    if (typeof e.message === "string") return e.message;
+    return String(error);
+  }
   const outerTag = String(e.tag);
   const inner = e.value;
   if (inner && typeof inner === "object") {
@@ -1015,7 +1004,14 @@ var SignerManager = class {
     this.onConnectController = controller;
     const ctx = {
       signal: controller.signal,
-      requestResourceAllocation
+      // Bridge host's `Result`-returning `requestResourceAllocation` back to
+      // the `ConnectContext` contract (`Promise<AllocationOutcome[]>`, throws
+      // on failure) by unwrapping the typed error on the `err` channel.
+      requestResourceAllocation: async (resources) => {
+        const result = await requestResourceAllocation(resources);
+        if (!result.ok) throw result.error;
+        return result.value;
+      }
     };
     queueMicrotask(async () => {
       try {