EIP-1898 object selectors fail before downstream RPC in eth-json-rpc-middleware 26.0.0

--- /dev/null
+++ b/packages/eth-json-rpc-middleware/src/eip1898-regression.test.ts
@@ -0,0 +1,159 @@
+import { PollingBlockTracker } from '@metamask/eth-block-tracker';
+import { InternalProvider } from '@metamask/eth-json-rpc-provider';
+import { JsonRpcEngineV2 } from '@metamask/json-rpc-engine/v2';
+import type { JsonRpcMiddleware } from '@metamask/json-rpc-engine/v2';
+import type { Json, JsonRpcRequest } from '@metamask/utils';
+
+import {
+  createRetryOnEmptyMiddleware,
+  createBlockCacheMiddleware,
+} from './index.js';
+
+type Counts = { tracker: number; terminal: number };
+type Harness = {
+  counts: Counts;
+  invoke: (method: string, params: Json[]) => Promise<Json>;
+};
+
+// Dropping either guard must fail at least one regression.
+describe('EIP-1898 selector preservation', () => {
+  const address = `0x${'11'.repeat(20)}`;
+  const hashOne = `0x${'ab'.repeat(32)}`;
+  const hashTwo = `0x${'cd'.repeat(32)}`;
+  const selectors: Json[] = [
+    { blockHash: hashOne, requireCanonical: true },
+    { blockNumber: '0x123' },
+  ];
+  const owned: (() => Promise<void>)[] = [];
+
+  afterEach(async () => {
+    for (const cleanup of owned.splice(0).reverse()) {
+      await cleanup();
+    }
+  });
+
+  function pipeline(
+    order: string[],
+    terminal: (request: Readonly<JsonRpcRequest>) => Json,
+  ): Harness {
+    const counts: Counts = { tracker: 0, terminal: 0 };
+    const remote = JsonRpcEngineV2.create<
+      JsonRpcMiddleware<JsonRpcRequest, Json>
+    >({
+      middleware: [
+        async (): Promise<Json> => {
+          counts.tracker += 1;
+          throw Error('OBJECT_SELECTOR_REACHED_NUMERIC_TRACKER');
+        },
+      ],
+    });
+    const provider = new InternalProvider({ engine: remote });
+    const tracker = new PollingBlockTracker({
+      provider,
+      keepEventLoopActive: false,
+    });
+    const stages: Record<string, JsonRpcMiddleware<JsonRpcRequest, Json>> = {
+      cache: createBlockCacheMiddleware({ blockTracker: tracker }),
+      retry: createRetryOnEmptyMiddleware({ provider, blockTracker: tracker }),
+    };
+    const engine = JsonRpcEngineV2.create<
+      JsonRpcMiddleware<JsonRpcRequest, Json>
+    >({
+      middleware: [
+        ...order.map((key) => stages[key]),
+        async ({ request }): Promise<Json> => {
+          counts.terminal += 1;
+          return terminal(request);
+        },
+      ],
+    });
+    owned.push(async (): Promise<void> => {
+      await tracker.destroy();
+      await engine.destroy();
+      await remote.destroy();
+    });
+    let requestId = 0;
+    return {
+      counts,
+      invoke: (method: string, params: Json[]): Promise<Json> => {
+        requestId += 1;
+        return engine.handle({ jsonrpc: '2.0', id: requestId, method, params });
+      },
+    };
+  }
+
+  for (const order of [
+    ['cache', 'retry'],
+    ['retry', 'cache'],
+  ]) {
+    for (const method of [
+      'eth_call',
+      'eth_getBalance',
+      'eth_getCode',
+      'eth_getTransactionCount',
+      'eth_getStorageAt',
+    ]) {
+      for (const selector of selectors) {
+        it(`${order.join('→')} forwards selector for ${method} ${JSON.stringify(selector)}`, async () => {
+          let params: Json[];
+          if (method === 'eth_call') {
+            params = [{ to: address, data: '0x313ce567' }, selector];
+          } else if (method === 'eth_getStorageAt') {
+            params = [address, '0x0', selector];
+          } else {
+            params = [address, selector];
+          }
+          const harness = pipeline(order, (request) => {
+            expect(request.params).toStrictEqual(params);
+            return '0x1234';
+          });
+          expect(await harness.invoke(method, params)).toBe('0x1234');
+          expect(harness.counts).toStrictEqual({ tracker: 0, terminal: 1 });
+        });
+      }
+    }
+    for (const reason of ['NON_CANONICAL', 'UNKNOWN_BLOCK', 'RATE_LIMIT']) {
+      it(`${order.join('→')} preserves downstream ${reason} without retry/cache`, async () => {
+        const error = Object.assign(new Error(reason), { code: -32000 });
+        let fail = true;
+        const harness = pipeline(order, () => {
+          if (fail) {
+            throw error;
+          }
+          return '0xbeef';
+        });
+        const params: Json[] = [
+          { to: address },
+          { blockHash: hashOne, requireCanonical: true },
+        ];
+        await expect(harness.invoke('eth_call', params)).rejects.toBe(error);
+        fail = false;
+        expect(await harness.invoke('eth_call', params)).toBe('0xbeef');
+        expect(harness.counts).toStrictEqual({ tracker: 0, terminal: 2 });
+      });
+    }
+  }
+
+  it('block cache keeps hash/canonical responses separate across repeated calls', async () => {
+    let index = 0;
+    const responses = ['0xaa', '0xbb', '0xcc'];
+    const harness = pipeline(['cache'], () => {
+      const result = responses[index];
+      index += 1;
+      if (result === undefined) {
+        throw Error('UNEXPECTED_EXTRA_DOWNSTREAM_REQUEST');
+      }
+      return result;
+    });
+    for (const [selector, expected] of [
+      [{ blockHash: hashOne, requireCanonical: true }, '0xaa'],
+      [{ blockHash: hashOne, requireCanonical: false }, '0xbb'],
+      [{ blockHash: hashTwo, requireCanonical: true }, '0xcc'],
+    ] as const) {
+      expect(
+        await harness.invoke('eth_call', [{ to: address }, selector]),
+      ).toBe(expected);
+    }
+    expect(harness.counts).toStrictEqual({ tracker: 0, terminal: 3 });
+  });
+});