fix(nip46): initialize RPC subscription in fromPayload() (#332)

When restoring an NDKNip46Signer via fromPayload(), the RPC
subscription was never initialized because startListening() was not
called. This caused sign(), encrypt(), and decrypt() to hang
indefinitely since no subscription was listening for NIP-46 responses.

The fix adds `await signer.startListening()` to fromPayload() before
returning the signer, matching the behavior of blockUntilReady() and
other initialization paths.

Tests:
- Added test verifying fromPayload() initializes the RPC subscription
- Added test verifying sign() works on a restored signer
- Updated mock NDK to support subscribe() for startListening() tests
- Updated serialization test to mock startListening() for isolation

Closes #332

Author: Execution Coordinator

core/src/signers/nip46/index.test.ts

@@ -15,6 +15,13 @@ function createMockNDK() {
         debug: debugMock,
         getUser: vi.fn((opts: { pubkey: string }) => new NDKUser({ pubkey: opts.pubkey })),
         pools: [],
+        // Mock subscribe: returns a subscription-like object and immediately triggers onEose
+        subscribe: vi.fn((_filter: any, opts: any) => {
+            const sub = { stop: vi.fn(), on: vi.fn(), off: vi.fn() };
+            // Trigger onEose asynchronously so the RPC subscribe promise resolves
+            if (opts?.onEose) queueMicrotask(() => opts.onEose());
+            return sub;
+        }),
     } as unknown as NDK;
 }
 
@@ -249,6 +256,52 @@ describe("NDKNip46Signer", () => {
             expect(parsed.payload.bunkerPubkey).toBe("bunkerpubkey");
             expect(parsed.payload.localSignerPayload).toBeDefined();
         });
+
+        it("fromPayload initializes the RPC subscription (issue #332)", async () => {
+            // Create and serialize a signer
+            const token = `bunker://${bob.pubkey}?pubkey=${alice.pubkey}&relay=wss://relay.nsec.app`;
+            const signer = new NDKNip46Signer(ndk, token, localSigner);
+            const payload = signer.toPayload();
+
+            // Deserialize — fromPayload should call startListening()
+            const deserialized = await NDKNip46Signer.fromPayload(payload, ndk);
+
+            // The subscription should have been initialized
+            expect((deserialized as any).subscription).toBeDefined();
+        });
+
+        it("restored signer can sign events via RPC (issue #332)", async () => {
+            // Create and serialize a signer
+            const token = `bunker://${bob.pubkey}?pubkey=${alice.pubkey}&relay=wss://relay.nsec.app`;
+            const signer = new NDKNip46Signer(ndk, token, localSigner);
+            const payload = signer.toPayload();
+
+            // Deserialize
+            const deserialized = await NDKNip46Signer.fromPayload(payload, ndk);
+
+            // Replace the RPC with a mock that responds to sign requests
+            const mockRpc = createMockRpc();
+            (deserialized as any).rpc = mockRpc;
+
+            (mockRpc.sendRequest as any).mockImplementation(
+                (_bunkerPubkey: string, _method: string, _params: any[], _kind: number, cb: Function) => {
+                    cb({ result: JSON.stringify({ sig: "restored-sig" }) });
+                },
+            );
+
+            const event: NostrEvent = {
+                kind: 1,
+                pubkey: alice.pubkey,
+                created_at: Math.floor(Date.now() / 1000),
+                tags: [],
+                content: "test",
+                id: "eventid",
+                sig: "signature",
+            };
+
+            const sig = await deserialized.sign(event);
+            expect(sig).toBe("restored-sig");
+        });
     });
 
     describe("error handling", () => {

core/src/signers/nip46/index.ts

@@ -600,6 +600,12 @@ export class NDKNip46Signer extends EventEmitter implements NDKSigner {
             signer._user = new NDKUser({ pubkey: payload.userPubkey });
             if (signer._user) signer._user.ndk = ndk;
         }
+
+        // Initialize the RPC subscription so that sign/encrypt/decrypt
+        // requests receive responses. Without this, operations hang
+        // indefinitely because no subscription is listening.
+        await signer.startListening();
+
         return signer;
     }
 }

core/src/signers/serialization.test.ts

@@ -116,6 +116,11 @@ describe("Signer Serialization/Deserialization", () => {
             payload: localSigner.privateKey,
         });
 
+        // Mock startListening to avoid real relay subscriptions during deserialization
+        const mockStartListening = vi
+            .spyOn(NDKNip46Signer.prototype as any, "startListening")
+            .mockResolvedValue(undefined);
+
         // Mock blockUntilReady for the deserialized instance to avoid network calls
         // and simulate successful connection/user retrieval.
         const mockBlockUntilReady = vi