@parity/product-sdk-signer 0.8.2 → 0.9.0

package/src/signer-manager.ts

@@ -671,7 +671,14 @@ export class SignerManager {
 
         const ctx: ConnectContext = {
             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;
+            },
         };
 
         // Defer so connect()/attemptReconnect() return before the callback fires —
@@ -890,6 +897,28 @@ if (import.meta.vitest) {
             manager.destroy();
         });
 
+        test("ctx.requestResourceAllocation unwraps host errors by throwing", async () => {
+            // The ctx helper adapts host's `Result`-returning
+            // `requestResourceAllocation` to the throwing `ConnectContext`
+            // contract. Outside a container the host call returns `err`, so the
+            // adapter must throw (not return a `Result` object).
+            let captured: ConnectContext | undefined;
+            const onConnect = vi.fn().mockImplementation((_account, ctx: ConnectContext) => {
+                captured = ctx;
+            });
+            const manager = new SignerManager({
+                createProvider: () => mockProvider(),
+                onConnect,
+            });
+            await manager.connect("dev");
+            await flush();
+            expect(captured).toBeDefined();
+            await expect(
+                captured?.requestResourceAllocation([{ tag: "AutoSigning", value: undefined }]),
+            ).rejects.toThrow();
+            manager.destroy();
+        });
+
         test("re-connecting cancels in-flight onConnect from the prior session", async () => {
             const signals: AbortSignal[] = [];
             const onConnect = vi.fn().mockImplementation((_, ctx) => {

package/src/types.ts

@@ -119,10 +119,11 @@ export 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
@@ -133,7 +134,7 @@ export 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) {
@@ -155,9 +156,10 @@ export 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[]>;
 }