test(rpc): drop probe tests that guard nothing

Three of the tests written while designing the cursor interceptor were
exploration scaffolding, not regression guards:

CursorInterceptorAttachmentTest drove probe services only, so switching
the production code back to server-level attachment left it green; the
wiring it was meant to justify is now covered by
CursorInterceptorWiringTest, and the reasoning belongs in the PR.

WalletSolidityApiMethodSubsetTest asserted every WalletSolidity method
exists on WalletApi, which the compiler enforces now that the handlers
delegate by name. It would also fail on a legitimate WalletSolidity-only
method implemented in place.

GrpcInterceptorProbeTest kept an ordering assertion whose premise no
longer holds — service-level attachment made registration order
irrelevant to the cursor services — plus two library-property tests
already covered through the production interceptor, and printed traces
left over from probing.

What that last class did earn is kept as CursorInterceptorServerTest: a
real server proving gRPC runs the handler inline from onHalfClose on the
same thread, which CursorInterceptorScopeTest cannot show on its
synthetic harness and which fails silently in production if it breaks.

Also drops two javadoc references to the deleted subset test.

Author: Little-Peony

framework/src/main/java/org/tron/core/services/RpcApiService.java

@@ -365,8 +365,8 @@ public void getDynamicProperties(EmptyMessage request,
 
   /**
    * WalletSolidityApi is the full implementation of the {@code protocol.WalletSolidity} gRPC
-   * service. Every method here is read-only and also present on {@link WalletApi}: this is a
-   * read-only subset of {@code WalletApi}, guarded by {@code WalletSolidityApiMethodSubsetTest}.
+   * service. Every method here is read-only and also present on {@link WalletApi}, so each one
+   * delegates to the shared {@code WalletApi} singleton instead of repeating its body.
    */
   public class WalletSolidityApi extends WalletSolidityImplBase {
 
@@ -667,8 +667,8 @@ private TransactionListExtention transactionList2Extention(TransactionList trans
 
   /**
    * WalletApi is the full implementation of the {@code protocol.Wallet} gRPC service, including
-   * write and build endpoints. {@link WalletSolidityApi} is the read-only subset of this surface,
-   * pinned by {@code WalletSolidityApiMethodSubsetTest}.
+   * write and build endpoints. {@link WalletSolidityApi} is the read-only subset of this surface
+   * and delegates its handlers here.
    */
   public class WalletApi extends WalletImplBase {
 

framework/src/test/java/org/tron/core/services/WalletSolidityApiMethodSubsetTest.java

@@ -0,0 +1,123 @@
+package org.tron.core.services.filter;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.stub.StreamObserver;
+import java.lang.reflect.Field;
+import java.net.ServerSocket;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.tron.api.DatabaseGrpc;
+import org.tron.api.DatabaseGrpc.DatabaseImplBase;
+import org.tron.api.GrpcAPI.EmptyMessage;
+import org.tron.core.db.Manager;
+import org.tron.core.db2.core.Chainbase;
+import org.tron.protos.Protocol.Block;
+
+/**
+ * Drives the production interceptor through a real gRPC server, which is the only place the
+ * assumption it rests on can be checked: that gRPC runs the handler inline from
+ * {@code onHalfClose}, on the same thread. The cursor is a {@link ThreadLocal}, so if that stops
+ * holding the cursor never reaches the read path and the port serves HEAD data with no error —
+ * responses stay well-formed, so nothing else notices.
+ *
+ * <p>CursorInterceptorScopeTest covers the interceptor's own logic on a synthetic harness; this is
+ * the end-to-end half.
+ */
+public class CursorInterceptorServerTest {
+
+  private ExecutorService executor;
+
+  @Before
+  public void setUp() {
+    // a fixed thread pool mirrors the production server configuration
+    executor = Executors.newFixedThreadPool(2, r -> {
+      Thread thread = new Thread(r);
+      thread.setName("cursor-rpc-executor-" + thread.getId());
+      return thread;
+    });
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    if (executor != null) {
+      executor.shutdown();
+      if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
+        executor.shutdownNow();
+      }
+    }
+  }
+
+  @Test
+  public void testCursorIsSetAndRestoredOnTheHandlerThread() throws Exception {
+    final List<String> setOn = new CopyOnWriteArrayList<>();
+    final List<String> resetOn = new CopyOnWriteArrayList<>();
+    final String[] handlerOn = new String[1];
+
+    Manager manager = mock(Manager.class);
+    doAnswer(inv -> setOn.add(Thread.currentThread().getName()))
+        .when(manager).setCursor(any(Chainbase.Cursor.class));
+    doAnswer(inv -> resetOn.add(Thread.currentThread().getName()))
+        .when(manager).resetCursor();
+
+    SolidityCursorInterceptor interceptor = new SolidityCursorInterceptor();
+    Field dbManager = CursorServerInterceptor.class.getDeclaredField("dbManager");
+    dbManager.setAccessible(true);
+    dbManager.set(interceptor, manager);
+
+    int port = freePort();
+    Server server = ServerBuilder.forPort(port)
+        .executor(executor)
+        .addService(new DatabaseImplBase() {
+          @Override
+          public void getNowBlock(EmptyMessage request, StreamObserver<Block> observer) {
+            handlerOn[0] = Thread.currentThread().getName();
+            observer.onNext(Block.getDefaultInstance());
+            observer.onCompleted();
+          }
+        })
+        .intercept(interceptor)
+        .build()
+        .start();
+
+    ManagedChannel channel = ManagedChannelBuilder.forAddress("127.0.0.1", port)
+        .usePlaintext().directExecutor().build();
+    try {
+      DatabaseGrpc.newBlockingStub(channel).getNowBlock(EmptyMessage.getDefaultInstance());
+
+      Assert.assertEquals("cursor must be set exactly once per call", 1, setOn.size());
+      Assert.assertEquals("cursor must be restored exactly once per call", 1, resetOn.size());
+      Assert.assertNotNull("handler did not run", handlerOn[0]);
+      // the ThreadLocal cursor only reaches the read path if it is set on the handler's thread
+      Assert.assertEquals("cursor was set on a thread other than the handler's",
+          handlerOn[0], setOn.get(0));
+      Assert.assertEquals("cursor was restored on a thread other than the handler's",
+          handlerOn[0], resetOn.get(0));
+      verify(manager).setCursor(Chainbase.Cursor.SOLIDITY);
+    } finally {
+      channel.shutdownNow();
+      server.shutdownNow();
+      server.awaitTermination(5, TimeUnit.SECONDS);
+    }
+  }
+
+  private static int freePort() throws Exception {
+    try (ServerSocket socket = new ServerSocket(0)) {
+      return socket.getLocalPort();
+    }
+  }
+}

framework/src/test/java/org/tron/core/services/filter/CursorInterceptorAttachmentTest.java

@@ -35,7 +35,7 @@
  * <p>Registering without the interceptor binds the {@code addService(BindableService)} overload
  * rather than the {@code addService(ServerServiceDefinition)} one, so the two are distinguishable
  * here. What the interceptor does once attached is pinned by CursorInterceptorScopeTest and
- * GrpcInterceptorProbeTest.
+ * CursorInterceptorServerTest.
  */
 public class CursorInterceptorWiringTest {