rpcclient: resolve all batch futures if Send fails

diff --git a/rpcclient/infrastructure.go b/rpcclient/infrastructure.go
index 09856c6..8018497 100644
--- a/rpcclient/infrastructure.go
+++ b/rpcclient/infrastructure.go
@@ -1762,6 +1762,38 @@ func (c *Client) sendAsync() (FutureGetBulkResult, error) {
 	return responseChan, nil
 }
 
+// failBatchRequests resolves every queued batch request with the provided error
+// and clears all internal request tracking.
+//
+// This function is safe for concurrent access.
+func (c *Client) failBatchRequests(err error) {
+	c.requestLock.Lock()
+	defer c.requestLock.Unlock()
+
+	c.batchLock.Lock()
+	defer c.batchLock.Unlock()
+
+	for e := c.batchList.Front(); e != nil; e = e.Next() {
+		req := e.Value.(*jsonRequest)
+
+		// Resolve all pending futures on the first batch-level failure
+		// so callers waiting on Receive don't block indefinitely.
+		// Safe: batch-mode responseChan buffers are unwritten here,
+		// so this send won't block while locks are held. Batch-mode
+		// requests only use addRequest (not sendPostRequest), so each
+		// responseChan buffer is still empty.
+		req.responseChan <- &Response{err: err}
+	}
+
+	c.requestMap = make(map[uint64]*list.Element)
+	c.batchList = list.New()
+
+	// Batch-mode requests are tracked in batchList, so requestList should
+	// already be empty. Keep this defensive reset for invariants and future
+	// call paths.
+	c.requestList.Init()
+}
+
 // Marshall's bulk requests and sends to the server
 // creates a response channel to receive the response
 func (c *Client) Send() error {
@@ -1772,12 +1804,7 @@ func (c *Client) Send() error {
 
 	batchResp, err := future.Receive()
 	if err != nil {
-		// Clear batchlist in case of an error.
-
-		c.batchLock.Lock()
-		c.batchList = list.New()
-		c.batchLock.Unlock()
-
+		c.failBatchRequests(err)
 		return err
 	}
 
diff --git a/rpcclient/infrastructure_test.go b/rpcclient/infrastructure_test.go
index bf09c65..5852edf 100644
--- a/rpcclient/infrastructure_test.go
+++ b/rpcclient/infrastructure_test.go
@@ -517,3 +517,65 @@ func TestSendPostRequestShutdownPrioritizesFailure(t *testing.T) {
 		}
 	}
 }
+
+// TestBatchSendErrorResolvesQueuedFutures ensures a batch send failure resolves
+// all queued futures instead of leaving them blocked.
+func TestBatchSendErrorResolvesQueuedFutures(t *testing.T) {
+	connCfg := &ConnConfig{
+		Host:         "127.0.0.1:8332",
+		User:         "user",
+		Pass:         "pass",
+		DisableTLS:   true,
+		HTTPPostMode: true,
+	}
+
+	client, err := NewBatch(connCfg)
+	require.NoError(t, err)
+	t.Cleanup(func() {
+		client.Shutdown()
+		client.WaitForShutdown()
+	})
+
+	client.httpClient.Transport = postRoundTripFunc(
+		func(*http.Request) (*http.Response, error) {
+			body := io.NopCloser(strings.NewReader("not-json"))
+
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Header:     make(http.Header),
+				Body:       body,
+			}, nil
+		},
+	)
+
+	f1 := client.GetBlockCountAsync()
+	f2 := client.GetBlockCountAsync()
+
+	sendErr := client.Send()
+	require.Error(t, sendErr)
+
+	assertFutureErr := func(f FutureGetBlockCountResult) {
+		t.Helper()
+
+		done := make(chan error, 1)
+		// Receive is the blocking caller-facing path. The old bug surfaced here
+		// by never resolving the future, so bound it with a timeout.
+		go func() {
+			_, err := f.Receive()
+			done <- err
+		}()
+
+		select {
+		case err := <-done:
+			require.Error(t, err)
+			require.EqualError(t, err, sendErr.Error())
+
+		case <-time.After(2 * time.Second):
+			t.Fatal("timed out waiting for queued batch future " +
+				"to resolve")
+		}
+	}
+
+	assertFutureErr(f1)
+	assertFutureErr(f2)
+}