feat(sdk): Provider waits for selection, runs producer, and publishes encrypted result (P2 chunk 7b)

Provider.serve advances steps 5-7 of the wire flow:

  5. After publishing the kind 7000 quote, subscribe to the customer's
     kind 7000 status="processing" selection event referencing our
     request event id, addressed to us via the `p` tag. Time out after
     selectionTimeoutMs (default 60s).
  6. If selected, invoke the lazy quote.produce() to obtain
     { data, proof }. Errors here mean the provider cannot fulfill;
     bail silently — the customer's HTLC locktime refund kicks in.
  7. Build + publish the kind 6300 result event with NIP-44-encrypted
     content (schema + data + proof) addressed to the customer's
     ephemeral pubkey via buildQueryResponseEvent.

Step 8-10 (NIP-44 DM preimage delivery + Cashu HTLC redemption) land
in P2 chunk 7c.

waitForSelection is implemented with the same wrapper-object pattern
the customer uses for its result-event timeout, so no `let`
reassignment trips prefer-const and the timeout is cleared on a
successful selection (no Deno test-runner leak).

Tests: 2 new (180 total in test:packages, was 178). End-to-end
verifies producer runs after a delivered selection event, the kind
6300 content decrypts back to the producer's data + proof under the
customer's NIP-44 keypair, and producer is not run when no selection
arrives within the timeout.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: motxx

packages/sdk/src/provider.test.ts

@@ -7,8 +7,12 @@ import {
   shouldQuote,
   validateProviderOptions,
 } from "./provider.ts";
-import { buildQueryRequestEvent } from "./events.ts";
 import {
+  buildQueryRequestEvent,
+  buildSelectionFeedbackEvent,
+} from "./events.ts";
+import {
+  decryptNip44,
   generateKeypair,
   type Event,
   type Filter,
@@ -206,8 +210,10 @@ test("Provider.serve publishes a kind 7000 quote when handler returns a Provider
   let onEventRef: ((e: Event) => void) | null = null;
 
   const relayClient = makeRelayClient({
-    subscribe: (_filter: Filter, onEvent: (e: Event) => void): Subscription => {
-      onEventRef = onEvent;
+    subscribe: (filter: Filter, onEvent: (e: Event) => void): Subscription => {
+      // Capture only the request subscription (kinds: [5300]); ignore
+      // the per-job selection subscription so its timeout fires fast.
+      if ((filter.kinds ?? []).includes(5300)) onEventRef = onEvent;
       return { close: () => {} };
     },
     publish: async (event: Event): Promise<PublishResult> => {
@@ -216,7 +222,11 @@ test("Provider.serve publishes a kind 7000 quote when handler returns a Provider
     },
   });
 
-  const provider = createProvider({ ...validOptions(), relayClient });
+  const provider = createProvider({
+    ...validOptions(),
+    relayClient,
+    selectionTimeoutMs: 30,
+  });
   const servePromise = provider.serve(async () => ({
     amountSats: 250,
     produce: async () => ({ data: null, proof: "p" }),
@@ -238,7 +248,9 @@ test("Provider.serve publishes a kind 7000 quote when handler returns a Provider
     locktime_seconds: Math.floor(Date.now() / 1000) + 3600,
     expires_at: Date.now() + 60_000,
   }));
-  await new Promise((r) => setTimeout(r, 10));
+  // Wait long enough for the per-job selection timeout (30ms) to fire,
+  // so no setTimeout leaks across to the test runner.
+  await new Promise((r) => setTimeout(r, 60));
   await provider.stop();
   await servePromise;
 
@@ -288,6 +300,157 @@ test("Provider.serve declines requests where handler returns null (no publish)",
   expect(published).toHaveLength(0);
 });
 
+test("Provider.serve waits for selection, runs producer, and publishes encrypted kind 6300 result", async () => {
+  const published: Event[] = [];
+  let onRequestEvent: ((e: Event) => void) | null = null;
+  let onSelectionEvent: ((e: Event) => void) | null = null;
+  let producerCalled = false;
+
+  const relayClient = makeRelayClient({
+    subscribe: (filter: Filter, onEvent: (e: Event) => void): Subscription => {
+      // First subscription is the request listener (kind 5300 only).
+      // Second subscription (per job) is the selection listener
+      // (kinds: [7000], #e: [requestId], authors: [customer]).
+      const kinds = filter.kinds ?? [];
+      if (kinds.includes(5300)) {
+        onRequestEvent = onEvent;
+      } else if (kinds.includes(7000)) {
+        onSelectionEvent = onEvent;
+      }
+      return { close: () => {} };
+    },
+    publish: async (event: Event): Promise<PublishResult> => {
+      published.push(event);
+      return { successes: ["wss://relay.example.org"], failures: [] };
+    },
+  });
+
+  const provider = createProvider({
+    ...validOptions(),
+    relayClient,
+    selectionTimeoutMs: 200,
+  });
+  const servePromise = provider.serve(async () => ({
+    amountSats: 200,
+    produce: async () => {
+      producerCalled = true;
+      return { data: { hello: "world" }, proof: "pf-bytes" };
+    },
+  }));
+
+  await new Promise((r) => setTimeout(r, 5));
+  if (onRequestEvent === null) throw new Error("request subscribe was not called");
+  const fireRequest = onRequestEvent as (e: Event) => void;
+
+  // Customer sends a request.
+  const requestEvent = buildQueryRequestEvent(customerKey, {
+    query_id: "q1",
+    schema: "io.anchr.tlsn-https.v1",
+    predicate: { foo: "bar" },
+    customer_pubkey: customerKey.publicKey,
+    oracle_pubkey: ORACLE_A,
+    mint_url: "https://mint.example.org",
+    bounty_token: "cashuB",
+    max_amount_sats: 1000,
+    locktime_seconds: Math.floor(Date.now() / 1000) + 3600,
+    expires_at: Date.now() + 60_000,
+  });
+  fireRequest(requestEvent);
+
+  // Wait for the provider to publish its quote and open the selection
+  // subscription before we deliver the selection event.
+  await new Promise((r) => setTimeout(r, 30));
+  if (onSelectionEvent === null) throw new Error("selection subscribe was not called");
+  const fireSelection = onSelectionEvent as (e: Event) => void;
+
+  // Customer announces selecting this provider, with a bound token.
+  const selectionEvent = buildSelectionFeedbackEvent(customerKey, requestEvent.id, {
+    status: "processing",
+    selected_provider_pubkey: providerKey.publicKey,
+    bound_token: "cashuBbound",
+  });
+  fireSelection(selectionEvent);
+
+  await new Promise((r) => setTimeout(r, 30));
+  await provider.stop();
+  await servePromise;
+
+  expect(producerCalled).toBe(true);
+  // Two publishes from the provider: kind 7000 quote + kind 6300 result.
+  expect(published).toHaveLength(2);
+  expect(published[0].kind).toBe(7000);
+  expect(published[1].kind).toBe(6300);
+
+  // The kind 6300 content is NIP-44-encrypted to the customer.
+  const decrypted = decryptNip44(
+    published[1].content,
+    customerKey.secretKey,
+    providerKey.publicKey,
+  );
+  const payload = JSON.parse(decrypted);
+  expect(payload.schema).toBe("io.anchr.tlsn-https.v1");
+  expect(payload.data).toEqual({ hello: "world" });
+  expect(payload.proof).toBe("pf-bytes");
+});
+
+test("Provider.serve never runs the producer when no selection event arrives within timeout", async () => {
+  const published: Event[] = [];
+  let onRequestEvent: ((e: Event) => void) | null = null;
+  let producerCalled = false;
+
+  const relayClient = makeRelayClient({
+    subscribe: (filter: Filter, onEvent: (e: Event) => void): Subscription => {
+      const kinds = filter.kinds ?? [];
+      if (kinds.includes(5300)) {
+        onRequestEvent = onEvent;
+      }
+      return { close: () => {} };
+    },
+    publish: async (event: Event): Promise<PublishResult> => {
+      published.push(event);
+      return { successes: ["wss://relay.example.org"], failures: [] };
+    },
+  });
+
+  const provider = createProvider({
+    ...validOptions(),
+    relayClient,
+    selectionTimeoutMs: 30,
+  });
+  const servePromise = provider.serve(async () => ({
+    amountSats: 100,
+    produce: async () => {
+      producerCalled = true;
+      return { data: null, proof: "x" };
+    },
+  }));
+
+  await new Promise((r) => setTimeout(r, 5));
+  if (onRequestEvent === null) throw new Error("request subscribe was not called");
+  (onRequestEvent as (e: Event) => void)(buildQueryRequestEvent(customerKey, {
+    query_id: "q1",
+    schema: "io.anchr.tlsn-https.v1",
+    predicate: {},
+    customer_pubkey: customerKey.publicKey,
+    oracle_pubkey: ORACLE_A,
+    mint_url: "https://mint.example.org",
+    bounty_token: "cashuB",
+    max_amount_sats: 1000,
+    locktime_seconds: Math.floor(Date.now() / 1000) + 3600,
+    expires_at: Date.now() + 60_000,
+  }));
+
+  // Wait beyond the selection timeout without delivering a selection.
+  await new Promise((r) => setTimeout(r, 80));
+  await provider.stop();
+  await servePromise;
+
+  expect(producerCalled).toBe(false);
+  // Only the kind 7000 quote was published; no kind 6300 result.
+  expect(published).toHaveLength(1);
+  expect(published[0].kind).toBe(7000);
+});
+
 test("Provider.serve does not publish a quote that exceeds the request's maxAmountSats", async () => {
   const published: Event[] = [];
   let onEventRef: ((e: Event) => void) | null = null;

packages/sdk/src/provider.ts

@@ -15,16 +15,18 @@
  */
 
 import {
+  buildQueryResponseEvent,
   buildQuoteFeedbackEvent,
   parseQueryRequestEvent,
+  parseSelectionFeedbackEvent,
 } from "./events.ts";
 import {
   createRelayClient,
   type Event as NostrEvent,
+  findTagValue,
   type Keypair,
   normalizeSecretKey,
   type RelayClient,
-  signEvent as _signEvent,
 } from "./nostr.ts";
 import { getPublicKey } from "nostr-tools/pure";
 import type {
@@ -248,9 +250,84 @@ async function handleJob(
   );
   await ctx.relayClient.publish(quoteEvent);
 
-  // TODO(P2 chunk 8): wait for selection event, run quote.produce(),
-  // encrypt+publish kind 6300, wait for oracle preimage DM, redeem HTLC.
-  void quote.produce; // captured for next chunk
-  void ctx.selectionTimeoutMs;
+  // [step 5] Wait for the customer's selection event (kind 7000
+  // status=processing) addressed to us. Time out after
+  // selectionTimeoutMs — the customer may select a different
+  // provider, in which case we never see a matching event.
+  const selection = await waitForSelection(
+    ctx,
+    event.id,
+    payload.customer_pubkey,
+  );
+  if (selection === null) return;
+
+  // [step 6] Run the lazy producer to generate the proof. Errors here
+  // mean we cannot fulfill the request — silently bail (locktime
+  // refunds the customer).
+  let result: { data: unknown; proof: Uint8Array | string };
+  try {
+    result = await quote.produce();
+  } catch {
+    return;
+  }
+
+  // [step 7] Build + publish the kind 6300 result event with the
+  // response NIP-44-encrypted to the customer's pubkey.
+  const responseEvent = buildQueryResponseEvent(
+    ctx.identity,
+    event.id,
+    payload.customer_pubkey,
+    {
+      schema: payload.schema,
+      data: result.data,
+      proof: result.proof,
+    },
+  );
+  await ctx.relayClient.publish(responseEvent);
+
+  // TODO(P2 chunk 7c): subscribe to NIP-44 DM (kind 4) from the
+  // oracle for the preimage, then redeem the HTLC at the mint.
+  void selection.bound_token; // captured for next chunk
   void ctx.cashuClient;
 }
+
+/**
+ * Wait for the customer's kind 7000 status=processing selection event
+ * referencing our quote. Returns the parsed selection payload, or
+ * null on timeout / no addressed-to-us event.
+ */
+function waitForSelection(
+  ctx: JobContext,
+  requestEventId: string,
+  customerPubkey: string,
+): Promise<{ bound_token: string } | null> {
+  return new Promise((resolve) => {
+    // Mutable holder so the subscribe callback can clear the timer
+    // and vice versa without `let` reassignment.
+    const handles: {
+      sub?: { close(): void };
+      timeoutId?: ReturnType<typeof setTimeout>;
+    } = {};
+    handles.sub = ctx.relayClient.subscribe(
+      {
+        kinds: [7000],
+        "#e": [requestEventId],
+        authors: [customerPubkey],
+      },
+      (event) => {
+        // The customer announces the selected provider via the `p` tag.
+        const selectedPubkey = findTagValue(event, "p");
+        if (selectedPubkey !== ctx.identity.publicKey) return;
+        const parsed = parseSelectionFeedbackEvent(event);
+        if (parsed === null) return;
+        handles.sub?.close();
+        if (handles.timeoutId !== undefined) clearTimeout(handles.timeoutId);
+        resolve({ bound_token: parsed.bound_token });
+      },
+    );
+    handles.timeoutId = setTimeout(() => {
+      handles.sub?.close();
+      resolve(null);
+    }, ctx.selectionTimeoutMs);
+  });
+}