Enforce check interval correctly

src/writeConfirm.ts

@@ -69,29 +69,29 @@ async function waitForEvent(
     const elapsed = Date.now() - started;
     const remainingMs = Math.max(1, timeoutMs - elapsed);
     const queryTimeoutMs = Math.max(200, Math.min(1_000, remainingMs));
-    const found = await withTimeout<boolean>(
+    const found = await new Promise<boolean>((resolve) => {
-      new Promise<boolean>((resolve) => {
       let settled = false;
-        const sub = relay.subscribe([filter], {
+      let sub: ReturnType<Relay["subscribe"]> | undefined;
-          onevent: (evt) => {
+      const finish = (found: boolean): void => {
         if (settled) return;
-            if (evt.id === expectedEventId) {
         settled = true;
-              sub.close();
+        clearTimeout(timer);
-              resolve(true);
+        sub?.close();
+        resolve(found);
+      };
+      const timer = setTimeout(() => finish(false), queryTimeoutMs);
+
+      sub = relay.subscribe([filter], {
+        onevent: (evt) => {
+          if (evt.id === expectedEventId) {
+            finish(true);
           }
         },
         oneose: () => {
-            if (settled) return;
+          finish(false);
-            settled = true;
-            sub.close();
-            resolve(false);
         },
       });
-      }),
+    });
-      queryTimeoutMs,
-      "write confirm read-after-write query",
-    ).catch(() => false);
 
     if (found) return true;
 
@@ -142,20 +142,20 @@ export async function runWriteConfirm(input: WriteConfirmInput): Promise<WriteCo
       };
     }
 
-    const elapsedMs = performance.now() - startedAt;
-    const remainingMs = Math.max(1, input.timeoutMs - Math.floor(elapsedMs));
-
     const confirmed = await waitForEvent(
       relay,
       {
+        ids: [event.id],
         authors: [derivedPubkey],
         kinds: [input.kind],
         "#d": [dTag],
-        limit: 1,
         since: Math.max(0, createdAt - 5),
       },
       event.id,
-      remainingMs,
+      // Connect and publish each have their own timeout, so read-after-write
+      // must receive one too. Charging all three stages to a single timeout
+      // can reduce this to 1 ms after a slow, successful publish.
+      input.timeoutMs,
     );
 
     return {