Stop daemon broadcast events from rejecting pending wallet_ui requests (#3012)

The main-process sendCommand socket registers as service wallet_ui, so
the daemon forwards every broadcast event to it (farming_info,
get_fee_estimate, get_connections, ...). Its message handler parsed
each frame with json-bigint's useNativeBigInt parser before checking
request_id, and that parser passes any number literal longer than 15
characters to BigInt() even when it contains a decimal point. A
harvester farming_info lookup time such as 1.7656183690123726 therefore
threw "Cannot convert 1.7656183690123726 to a BigInt", and the catch
block rejected whichever request happened to be pending.

Because get_offer_summary runs inside the take_offer confirmation flow,
any farm with slow-enough plot lookups hits this race on nearly every
offer accept: the user sees the BigInt error dialog and the offer
command is never sent to the wallet.

Parse incoming frames with the native-bigint parser first, fall back to
the BigNumber parser for frames carrying long-precision floats, and
ignore frames that are not valid JSON instead of rejecting the pending
request. Matched responses keep their existing native-bigint behavior.


Claude-Session: https://claude.ai/code/session_016jfMfuGTvCmMyL7EM92dmj

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: jlobue10

packages/gui/src/electron/api/sendCommand.test.ts

@@ -281,6 +281,71 @@ describe('sendCommand', () => {
     expect(rawMessage).not.toContain('9007199254740993n');
   });
 
+  it('ignores broadcast events with long-precision floats while a command is pending', async () => {
+    await startServer((socket, message) => {
+      if (message.command === 'register_service') {
+        socket.send(JSONBig.stringify({ request_id: message.request_id, data: { success: true } }));
+        return;
+      }
+
+      // Raw frame mimicking a chia_harvester farming_info broadcast: the
+      // lookup time float is longer than 15 characters, which used to make
+      // the useNativeBigInt parser throw and reject the pending request.
+      socket.send(
+        '{"ack":false,"command":"farming_info","data":{"challenge_hash":"0xabc","total_plots":1000,"time":1.7656183690123726},"destination":"wallet_ui","origin":"chia_harvester","request_id":"broadcast"}',
+      );
+      socket.send(JSONBig.stringify({ request_id: message.request_id, data: { success: true, value: 'done' } }));
+    });
+    const sendCommand = loadSendCommand();
+
+    await expect(sendCommand('get_offer_summary', 'chia_wallet')).resolves.toMatchObject({ value: 'done' });
+  });
+
+  it('resolves a matched response that contains long-precision floats', async () => {
+    await startServer((socket, message) => {
+      if (message.command === 'register_service') {
+        socket.send(JSONBig.stringify({ request_id: message.request_id, data: { success: true } }));
+        return;
+      }
+
+      socket.send(`{"request_id":"${message.request_id}","data":{"success":true,"fee_rate":1.7656183690123726}}`);
+    });
+    const sendCommand = loadSendCommand();
+
+    const response = await sendCommand<{ fee_rate: unknown }>('get_fee_estimate', 'chia_full_node');
+
+    expect(String(response.fee_rate)).toBe('1.7656183690123726');
+  });
+
+  it('ignores frames that are not valid JSON while a command is pending', async () => {
+    await startServer((socket, message) => {
+      if (message.command === 'register_service') {
+        socket.send(JSONBig.stringify({ request_id: message.request_id, data: { success: true } }));
+        return;
+      }
+
+      socket.send('not json');
+      socket.send(JSONBig.stringify({ request_id: message.request_id, data: { success: true, value: 'done' } }));
+    });
+    const sendCommand = loadSendCommand();
+
+    await expect(sendCommand('get_wallets', 'chia_wallet')).resolves.toMatchObject({ value: 'done' });
+  });
+
+  it('ignores broadcast events with long-precision floats during service registration', async () => {
+    await startServer((socket, message) => {
+      if (message.command === 'register_service') {
+        socket.send(
+          '{"ack":false,"command":"farming_info","data":{"time":1.2395747610135004},"destination":"wallet_ui","origin":"chia_harvester","request_id":"broadcast"}',
+        );
+      }
+      socket.send(JSONBig.stringify({ request_id: message.request_id, data: { success: true, value: 'done' } }));
+    });
+    const sendCommand = loadSendCommand();
+
+    await expect(sendCommand('get_network_info', 'chia_wallet')).resolves.toMatchObject({ value: 'done' });
+  });
+
   it('rejects daemon command errors', async () => {
     await startServer((socket, message) => {
       socket.send(

packages/gui/src/electron/api/sendCommand.ts

@@ -6,6 +6,26 @@ import { loadConfig } from '../utils/loadConfig';
 const REQUEST_TIMEOUT_MS = 10 * 60 * 1000;
 const JSONBigNative = JSONBig({ useNativeBigInt: true });
 
+// The wallet_ui socket also receives daemon broadcast events (farming_info,
+// get_fee_estimate, get_connections, ...). json-bigint with useNativeBigInt
+// passes any number literal longer than 15 characters to BigInt(), which
+// throws on the long-precision floats those events carry, so fall back to the
+// BigNumber-based parser before giving up on a frame. Returns undefined for
+// frames that are not valid JSON at all.
+function parseIncomingMessage(data: Buffer): any | undefined {
+  const text = data.toString();
+
+  try {
+    return JSONBigNative.parse(text);
+  } catch {
+    try {
+      return JSONBig.parse(text);
+    } catch {
+      return undefined;
+    }
+  }
+}
+
 let socketPromise: Promise<WebSocket> | undefined;
 
 async function connect(): Promise<WebSocket> {
@@ -37,12 +57,12 @@ async function connect(): Promise<WebSocket> {
     });
 
     function handleMessage(data: Buffer) {
-      try {
-        const response = JSONBigNative.parse(data.toString());
-        if (response.request_id !== requestId) {
-          return;
-        }
+      const response = parseIncomingMessage(data);
+      if (!response || response.request_id !== requestId) {
+        return;
+      }
 
+      try {
         if (!response.data.success) {
           throw new Error(`Daemon service is not registered`);
         }
@@ -167,12 +187,12 @@ export async function sendCommand<TResponse extends Record<string, unknown>>(
     }
 
     function handleMessage(data: Buffer) {
-      try {
-        const response = JSONBigNative.parse(data.toString());
-        if (response.request_id !== requestId) {
-          return;
-        }
+      const response = parseIncomingMessage(data);
+      if (!response || response.request_id !== requestId) {
+        return;
+      }
 
+      try {
         if (!response.data.success) {
           throw new Error(response.data.error);
         }