feat(sdk): publish Customer's kind 5300 Job Request via RelayClient (P2 chunk 4)

Adds the Nostr-publish step to Customer.request:

  - New module packages/sdk/src/events.ts defines QueryRequestPayload
    + buildQueryRequestEvent / parseQueryRequestEvent (round-trip)
  - Customer.request, after building the HTLC lock, builds a kind 5300
    event carrying { schema, predicate, customer_pubkey, oracle_pubkey,
    bounty_token, max_amount_sats, locktime_seconds, expires_at } and
    publishes it via the configured RelayClient
  - CustomerOptions gains optional `relayClient` (built from `relays`
    when omitted; tests inject mocks)
  - RelayPublishError surfaces "0 successes" responses cleanly so the
    caller knows the request did not reach any relay
  - Steps 6-11 (subscribe / select / decrypt / verify) remain TODO; the
    not-implemented marker now reports the published event id

Tests: 8 new (165 total in test:packages, was 157). Covers the round
trip of buildQueryRequestEvent / parseQueryRequestEvent (incl. tag
layout and rejection of malformed payloads), publish path through
mock RelayClient, and RelayPublishError on zero accepts.

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

Author: motxx

deno.json

@@ -72,7 +72,7 @@
     "test:ci": "deno test src/ packages/photo-bounty/ packages/tlsn-toolkit/ packages/cashu-frost-oracle/ packages/cashu-conditional-swap/ packages/core-runtime/ packages/core-cashu/ --allow-env --allow-read --allow-write --allow-net --allow-run --allow-sys '--ignore=src/**/*.integration.test.ts,packages/sdk/'",
     "test:example": "deno test --allow-all example/",
     "test": "deno test src/ packages/photo-bounty/ packages/tlsn-toolkit/ packages/cashu-frost-oracle/ packages/cashu-conditional-swap/ packages/core-runtime/ packages/core-cashu/ e2e/ --allow-env --allow-read --allow-write --allow-net --allow-run --allow-sys",
-    "test:packages": "deno test packages/photo-bounty/ packages/tlsn-toolkit/ packages/cashu-frost-oracle/ packages/cashu-conditional-swap/ packages/core-runtime/ packages/core-cashu/ packages/sdk/src/customer.test.ts packages/sdk/src/provider.test.ts packages/sdk/src/schema.test.ts packages/sdk/src/nostr.test.ts packages/sdk/src/oracle.test.ts packages/sdk/src/cashu.test.ts --allow-env --allow-read --allow-write --allow-net --allow-run --allow-sys",
+    "test:packages": "deno test packages/photo-bounty/ packages/tlsn-toolkit/ packages/cashu-frost-oracle/ packages/cashu-conditional-swap/ packages/core-runtime/ packages/core-cashu/ packages/sdk/src/customer.test.ts packages/sdk/src/provider.test.ts packages/sdk/src/schema.test.ts packages/sdk/src/nostr.test.ts packages/sdk/src/oracle.test.ts packages/sdk/src/cashu.test.ts packages/sdk/src/events.test.ts --allow-env --allow-read --allow-write --allow-net --allow-run --allow-sys",
     "test:pentest": "deno test e2e/pentest/ --allow-env --allow-read --allow-net --allow-run --allow-sys",
     "test:all": "./scripts/test-all.sh --local",
     "test:all:docker": "./scripts/test-all.sh --docker",

packages/sdk/deno.json

@@ -22,6 +22,7 @@
       "src/nostr.ts",
       "src/oracle.ts",
       "src/cashu.ts",
+      "src/events.ts",
       "README.md",
       "deno.json"
     ],
@@ -44,7 +45,7 @@
     "strict": true
   },
   "tasks": {
-    "test": "deno test --allow-env --allow-read --allow-net src/customer.test.ts src/provider.test.ts src/schema.test.ts src/nostr.test.ts src/oracle.test.ts src/cashu.test.ts"
+    "test": "deno test --allow-env --allow-read --allow-net src/customer.test.ts src/provider.test.ts src/schema.test.ts src/nostr.test.ts src/oracle.test.ts src/cashu.test.ts src/events.test.ts"
   },
   "test": {
     "exclude": ["src/index.test.ts", "src/worker.test.ts"]

packages/sdk/src/customer.test.ts

@@ -7,6 +7,7 @@ import {
   generateQueryId,
   OracleWhitelistMismatchError,
   pickOracleForRequest,
+  RelayPublishError,
   selectCheapestQuote,
   validateCustomerOptions,
 } from "./customer.ts";
@@ -21,6 +22,13 @@ import type {
   RedeemHtlcParams,
   RedeemResult,
 } from "./cashu.ts";
+import type {
+  Event,
+  Filter,
+  PublishResult,
+  RelayClient,
+  Subscription,
+} from "./nostr.ts";
 import type { CustomerOptions, Quote } from "./types.ts";
 
 // --- Test doubles ---
@@ -66,12 +74,30 @@ function makeCashuClient(overrides?: Partial<CashuClient>): CashuClient {
   };
 }
 
+function makeRelayClient(overrides?: Partial<RelayClient>): RelayClient {
+  return {
+    publish: overrides?.publish ?? (
+      async (_event: Event): Promise<PublishResult> => ({
+        successes: ["wss://relay.example.org"],
+        failures: [],
+      })
+    ),
+    subscribe: overrides?.subscribe ?? (
+      (_filter: Filter, _onEvent: (event: Event) => void): Subscription => ({
+        close: () => {},
+      })
+    ),
+    close: overrides?.close ?? (() => {}),
+  };
+}
+
 const validOptions = (): CustomerOptions => ({
   oracles: [ORACLE_A, ORACLE_B],
   relays: ["wss://relay.example.org"],
   mint: "https://mint.example.org",
   oracleClient: makeOracleClient(),
   cashuClient: makeCashuClient(),
+  relayClient: makeRelayClient(),
 });
 
 // --- Validation ---
@@ -243,15 +269,57 @@ test("Customer.request propagates CashuMintError from buildHtlcLock", async () =
   ).rejects.toThrow(CashuMintError);
 });
 
-test("Customer.request reaches the not-implemented marker for steps 5-11 when prior steps succeed", async () => {
+test("Customer.request reaches the not-implemented marker for steps 6-11 after publish", async () => {
   const customer = createCustomer(validOptions());
   await expect(
     customer.request({
       spec: { schema: "io.anchr.tlsn-https.v1", predicate: { foo: "bar" } },
       payment: { maxAmount: 1000 },
       sourceProofs: [],
     }),
-  ).rejects.toThrow(/wire flow steps 5-11 not implemented/);
+  ).rejects.toThrow(/wire flow steps 6-11 not implemented/);
+});
+
+test("Customer.request publishes a kind 5300 Job Request event via relayClient", async () => {
+  const recorder: { event: Event | null } = { event: null };
+  const relayClient = makeRelayClient({
+    publish: async (event: Event): Promise<PublishResult> => {
+      recorder.event = event;
+      return { successes: ["wss://relay.example.org"], failures: [] };
+    },
+  });
+  const customer = createCustomer({ ...validOptions(), relayClient });
+
+  await expect(
+    customer.request({
+      spec: { schema: "io.anchr.tlsn-https.v1", predicate: { foo: "bar" } },
+      payment: { maxAmount: 500 },
+      sourceProofs: [],
+    }),
+  ).rejects.toThrow();
+
+  expect(recorder.event).not.toBe(null);
+  if (recorder.event === null) throw new Error("unreachable");
+  expect(recorder.event.kind).toBe(5300);
+  expect(recorder.event.id).toMatch(/^[0-9a-f]{64}$/);
+});
+
+test("Customer.request throws RelayPublishError when no relay accepts the event", async () => {
+  const relayClient = makeRelayClient({
+    publish: async (): Promise<PublishResult> => ({
+      successes: [],
+      failures: [{ relay: "wss://relay.example.org", reason: "rejected" }],
+    }),
+  });
+  const customer = createCustomer({ ...validOptions(), relayClient });
+
+  await expect(
+    customer.request({
+      spec: { schema: "io.anchr.tlsn-https.v1", predicate: {} },
+      payment: { maxAmount: 1000 },
+      sourceProofs: [],
+    }),
+  ).rejects.toThrow(RelayPublishError);
 });
 
 // --- Pure helpers ---

packages/sdk/src/customer.ts

@@ -25,7 +25,14 @@ import {
   isSchemaUri,
   InvalidSchemaUriError,
 } from "./schema.ts";
-import { generateKeypair, type Keypair } from "./nostr.ts";
+import {
+  createRelayClient,
+  generateKeypair,
+  type Keypair,
+  type PublishResult,
+  type RelayClient,
+} from "./nostr.ts";
+import { buildQueryRequestEvent, type QueryRequestPayload } from "./events.ts";
 
 /**
  * Default quote-window in milliseconds. The SDK waits this long for
@@ -70,6 +77,17 @@ export class OracleWhitelistMismatchError extends Error {
   }
 }
 
+/** Thrown when no relay accepted the published Job Request event. */
+export class RelayPublishError extends Error {
+  constructor(public readonly result: PublishResult) {
+    super(
+      `No relay accepted the Job Request event ` +
+        `(${result.failures.length} failures, 0 successes).`,
+    );
+    this.name = "RelayPublishError";
+  }
+}
+
 /**
  * Pick one oracle from the customer's whitelist for this request.
  *
@@ -186,28 +204,57 @@ export function createCustomer(options: CustomerOptions): Customer {
         sourceProofs: req.sourceProofs,
       });
 
-      // Captured for the next-milestone wire-flow steps; explicitly
-      // referenced so static analysis treats them as used.
-      void quoteWindowMs;
-      void selector;
-      void verifiers;
-      void req.provider;
-      void initialLock;
-      void mint;
-
-      // TODO(P2 chunk 4-7): implement remaining wire flow:
-      //   5. Publish kind 5300 Job Request (relays + bounty token)
-      //   6. Subscribe to kind 7000 quotes for quoteWindowMs
-      //   7. Select via selector(quotes), bind HTLC to provider pubkey
-      //   8. Subscribe to kind 6300 result event
-      //   9. Decrypt response payload via NIP-44
-      //  10. Optionally call verifiers[req.spec.schema] for local verification
-      //  11. Return RequestResult
-      throw new Error(
-        "Customer.request: wire flow steps 5-11 not implemented in v0.0.1. " +
-          "Hash retrieved (oracle " + oraclePubkey + "), HTLC built. " +
-          "Remaining steps tracked as P2 chunks 4-7.",
-      );
+      // [step 5] Build + publish the kind 5300 Job Request event. Use
+      // an injected RelayClient when available (tests inject a mock);
+      // otherwise build one from the configured relays for this call.
+      const ownsRelayClient = options.relayClient === undefined;
+      const relayClient: RelayClient = options.relayClient ?? createRelayClient(relays);
+
+      try {
+        const requestPayload: QueryRequestPayload = {
+          query_id: queryId,
+          schema: req.spec.schema,
+          predicate: req.spec.predicate,
+          description: req.spec.description,
+          customer_pubkey: identity.publicKey,
+          oracle_pubkey: oraclePubkey,
+          mint_url: mint,
+          bounty_token: initialLock.token,
+          max_amount_sats: req.payment.maxAmount,
+          locktime_seconds: locktimeSeconds,
+          expires_at: Date.now() + quoteWindowMs,
+        };
+        const requestEvent = buildQueryRequestEvent(identity, requestPayload);
+        const publishResult = await relayClient.publish(requestEvent);
+
+        if (publishResult.successes.length === 0) {
+          throw new RelayPublishError(publishResult);
+        }
+
+        // Captured for the next-milestone wire-flow steps; explicitly
+        // referenced so static analysis treats them as used.
+        void selector;
+        void verifiers;
+        void req.provider;
+
+        // TODO(P2 chunk 5-7): implement remaining wire flow:
+        //   6. Subscribe to kind 7000 quotes for quoteWindowMs
+        //   7. Select via selector(quotes), bind HTLC to provider pubkey
+        //   8. Subscribe to kind 6300 result event
+        //   9. Decrypt response payload via NIP-44
+        //  10. Optionally call verifiers[req.spec.schema] for local verification
+        //  11. Return RequestResult
+        throw new Error(
+          "Customer.request: wire flow steps 6-11 not implemented in v0.0.1. " +
+            `Job Request event ${requestEvent.id.slice(0, 16)}… ` +
+            `accepted by ${publishResult.successes.length} of ` +
+            `${publishResult.successes.length + publishResult.failures.length} relays.`,
+        );
+      } finally {
+        if (ownsRelayClient) {
+          relayClient.close();
+        }
+      }
     },
   };
 }

packages/sdk/src/events.test.ts

@@ -0,0 +1,106 @@
+import { test } from "@std/testing/bdd";
+import { expect } from "@std/expect";
+
+import {
+  buildQueryRequestEvent,
+  parseQueryRequestEvent,
+  type QueryRequestPayload,
+} from "./events.ts";
+import {
+  findAllTagValues,
+  findTagValue,
+  generateKeypair,
+  KIND_QUERY_REQUEST,
+} from "./nostr.ts";
+
+function samplePayload(overrides?: Partial<QueryRequestPayload>): QueryRequestPayload {
+  return {
+    query_id: "query_abc",
+    schema: "io.anchr.tlsn-https.v1",
+    predicate: { target: "https://api.example.org" },
+    description: "test",
+    customer_pubkey: "11".repeat(32),
+    oracle_pubkey: "22".repeat(32),
+    mint_url: "https://mint.example.org",
+    bounty_token: "cashuBfake",
+    max_amount_sats: 1000,
+    locktime_seconds: Math.floor(Date.now() / 1000) + 3600,
+    expires_at: Date.now() + 600_000,
+    ...overrides,
+  };
+}
+
+test("buildQueryRequestEvent produces a kind 5300 signed event", () => {
+  const identity = generateKeypair();
+  const event = buildQueryRequestEvent(identity, samplePayload());
+
+  expect(event.kind).toBe(KIND_QUERY_REQUEST);
+  expect(event.pubkey).toBe(identity.publicKey);
+  expect(event.id).toMatch(/^[0-9a-f]{64}$/);
+  expect(event.sig).toMatch(/^[0-9a-f]{128}$/);
+});
+
+test("buildQueryRequestEvent emits the d / t / p / schema tags", () => {
+  const identity = generateKeypair();
+  const payload = samplePayload();
+  const event = buildQueryRequestEvent(identity, payload);
+
+  expect(findTagValue(event, "d")).toBe(payload.query_id);
+  expect(findAllTagValues(event, "t")).toContain("anchr");
+  expect(findTagValue(event, "p")).toBe(payload.oracle_pubkey);
+  expect(findTagValue(event, "schema")).toBe(payload.schema);
+});
+
+test("parseQueryRequestEvent recovers a payload from the built event (round-trip)", () => {
+  const identity = generateKeypair();
+  const payload = samplePayload();
+  const event = buildQueryRequestEvent(identity, payload);
+  const parsed = parseQueryRequestEvent(event);
+
+  expect(parsed).not.toBe(null);
+  expect(parsed?.query_id).toBe(payload.query_id);
+  expect(parsed?.schema).toBe(payload.schema);
+  expect(parsed?.customer_pubkey).toBe(payload.customer_pubkey);
+  expect(parsed?.oracle_pubkey).toBe(payload.oracle_pubkey);
+  expect(parsed?.bounty_token).toBe(payload.bounty_token);
+  expect(parsed?.max_amount_sats).toBe(payload.max_amount_sats);
+});
+
+test("parseQueryRequestEvent returns null for a non-kind-5300 event", () => {
+  const event = {
+    kind: 1,
+    pubkey: "00".repeat(32),
+    id: "00".repeat(32),
+    sig: "00".repeat(64),
+    created_at: 0,
+    content: JSON.stringify(samplePayload()),
+    tags: [],
+  };
+  expect(parseQueryRequestEvent(event)).toBe(null);
+});
+
+test("parseQueryRequestEvent returns null for unparseable content", () => {
+  const event = {
+    kind: KIND_QUERY_REQUEST,
+    pubkey: "00".repeat(32),
+    id: "00".repeat(32),
+    sig: "00".repeat(64),
+    created_at: 0,
+    content: "{not json",
+    tags: [],
+  };
+  expect(parseQueryRequestEvent(event)).toBe(null);
+});
+
+test("parseQueryRequestEvent returns null when required fields are missing", () => {
+  const event = {
+    kind: KIND_QUERY_REQUEST,
+    pubkey: "00".repeat(32),
+    id: "00".repeat(32),
+    sig: "00".repeat(64),
+    created_at: 0,
+    content: JSON.stringify({ query_id: "abc", schema: "io.x.y.v1" }),
+    tags: [],
+  };
+  expect(parseQueryRequestEvent(event)).toBe(null);
+});