Migrate to JsonRpcEngineV2

Update middleware to use the V2 API from @metamask/json-rpc-engine/v2:
- Use new middleware signature: async ({ request, context, next }) => result
- Return results directly instead of mutating res.result
- Use createScaffoldMiddleware from /v2 subpath
- Update test infrastructure to use JsonRpcEngineV2.create()

Also bump dev dependencies:
- @metamask/eth-block-tracker: ^11.0.1 → ^15.0.0
- @metamask/eth-json-rpc-middleware: ^15.0.0 → ^22.0.1

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: rekmarks

index.js

@@ -1,5 +1,5 @@
 const Mutex = require('async-mutex').Mutex
-const { createAsyncMiddleware, createScaffoldMiddleware } = require('@metamask/json-rpc-engine')
+const { createScaffoldMiddleware } = require('@metamask/json-rpc-engine/v2')
 const LogFilter = require('./log-filter.js')
 const BlockFilter = require('./block-filter.js')
 const TxFilter = require('./tx-filter.js')
@@ -22,10 +22,10 @@ function createEthFilterMiddleware({ blockTracker, provider }) {
     eth_newBlockFilter:              waitForFree(toFilterCreationMiddleware(newBlockFilter)),
     eth_newPendingTransactionFilter: waitForFree(toFilterCreationMiddleware(newPendingTransactionFilter)),
     // uninstall filters
-    eth_uninstallFilter:             waitForFree(toAsyncRpcMiddleware(uninstallFilterHandler)),
+    eth_uninstallFilter:             waitForFree(toRpcMiddleware(uninstallFilterHandler)),
     // checking filter changes
-    eth_getFilterChanges:            waitForFree(toAsyncRpcMiddleware(getFilterChanges)),
-    eth_getFilterLogs:               waitForFree(toAsyncRpcMiddleware(getFilterLogs)),
+    eth_getFilterChanges:            waitForFree(toRpcMiddleware(getFilterChanges)),
+    eth_getFilterLogs:               waitForFree(toRpcMiddleware(getFilterLogs)),
   })
 
   // setup filter updating and destroy handler
@@ -72,19 +72,19 @@ function createEthFilterMiddleware({ blockTracker, provider }) {
 
   async function newLogFilter(params) {
     const filter = new LogFilter({ provider, params })
-    const filterIndex = await installFilter(filter)
+    await installFilter(filter)
     return filter
   }
 
   async function newBlockFilter() {
     const filter = new BlockFilter({ provider })
-    const filterIndex = await installFilter(filter)
+    await installFilter(filter)
     return filter
   }
 
   async function newPendingTransactionFilter() {
     const filter = new TxFilter({ provider })
-    const filterIndex = await installFilter(filter)
+    await installFilter(filter)
     return filter
   }
 
@@ -185,30 +185,30 @@ function createEthFilterMiddleware({ blockTracker, provider }) {
 
 // helper for turning filter constructors into rpc middleware
 function toFilterCreationMiddleware(createFilterFn) {
-  return toAsyncRpcMiddleware(async (...args) => {
+  return toRpcMiddleware(async (...args) => {
     const filter = await createFilterFn(...args)
     const result = intToHex(filter.id)
     return result
   })
 }
 
-// helper for pulling out req.params and setting res.result
-function toAsyncRpcMiddleware(asyncFn) {
-  return createAsyncMiddleware(async (req, res) => {
-    const result = await asyncFn.apply(null, req.params)
-    res.result = result
-  })
+// helper for pulling out request.params and returning result (V2 middleware)
+function toRpcMiddleware(asyncFn) {
+  return async ({ request }) => {
+    const result = await asyncFn.apply(null, request.params)
+    return result
+  }
 }
 
 function mutexMiddlewareWrapper({ mutex }) {
   return (middleware) => {
-    return async (req, res, next, end) => {
+    return async (args) => {
       // wait for mutex available
       // we can release immediately because
       // we just need to make sure updates aren't active
       const releaseLock = await mutex.acquire()
       releaseLock()
-      middleware(req, res, next, end)
+      return middleware(args)
     }
   }
 }

package.json

@@ -20,16 +20,16 @@
   ],
   "dependencies": {
     "@metamask/eth-query": "^4.0.0",
-    "@metamask/json-rpc-engine": "^10.0.0",
+    "@metamask/json-rpc-engine": "^10.2.0",
     "@metamask/safe-event-emitter": "^3.0.0",
     "async-mutex": "^0.5.0",
     "pify": "^5.0.0"
   },
   "devDependencies": {
     "@lavamoat/allow-scripts": "^2.5.1",
     "@metamask/auto-changelog": "^3.3.0",
-    "@metamask/eth-json-rpc-middleware": "^15.0.0",
-    "@metamask/eth-block-tracker": "^11.0.1",
+    "@metamask/eth-block-tracker": "^15.0.0",
+    "@metamask/eth-json-rpc-middleware": "^22.0.1",
     "ganache": "^7.9.2",
     "sinon": "^15.2.0",
     "tape": "^5.7.0"

subscriptionManager.js

@@ -1,5 +1,5 @@
 const SafeEventEmitter = require('@metamask/safe-event-emitter').default
-const { createAsyncMiddleware, createScaffoldMiddleware } = require('@metamask/json-rpc-engine')
+const { createScaffoldMiddleware } = require('@metamask/json-rpc-engine/v2')
 const createFilterMiddleware = require('./index.js')
 const { unsafeRandomBytes, incrementHexInt } = require('./hexUtils.js')
 const getBlocksForRange = require('./getBlocksForRange.js')
@@ -18,19 +18,19 @@ function createSubscriptionMiddleware({ blockTracker, provider }) {
   // create subscriptionManager api object
   const events = new SafeEventEmitter()
   const middleware = createScaffoldMiddleware({
-    eth_subscribe: createAsyncMiddleware(subscribe),
-    eth_unsubscribe: createAsyncMiddleware(unsubscribe),
+    eth_subscribe: subscribe,
+    eth_unsubscribe: unsubscribe,
   })
   middleware.destroy = destroy
   return { events, middleware }
 
-  async function subscribe(req, res) {
+  async function subscribe({ request }) {
 
     if (isDestroyed) throw new Error(
       'SubscriptionManager - attempting to use after destroying'
     )
 
-    const subscriptionType = req.params[0]
+    const subscriptionType = request.params[0]
     // subId is 16 byte hex string
     const subId = unsafeRandomBytes(16)
 
@@ -41,7 +41,7 @@ function createSubscriptionMiddleware({ blockTracker, provider }) {
         sub = createSubNewHeads({ subId })
         break
       case 'logs':
-        const filterParams = req.params[1]
+        const filterParams = request.params[1]
         const filter = await filterManager.newLogFilter(filterParams)
         sub = createSubFromFilter({ subId, filter })
         break
@@ -51,8 +51,7 @@ function createSubscriptionMiddleware({ blockTracker, provider }) {
     }
     subscriptions[subId] = sub
 
-    res.result = subId
-    return
+    return subId
 
     function createSubNewHeads({ subId }) {
       const sub = {
@@ -88,23 +87,22 @@ function createSubscriptionMiddleware({ blockTracker, provider }) {
     }
   }
 
-  async function unsubscribe(req, res) {
+  async function unsubscribe({ request }) {
 
     if (isDestroyed) throw new Error(
       'SubscriptionManager - attempting to use after destroying'
     )
 
-    const id = req.params[0]
+    const id = request.params[0]
     const subscription = subscriptions[id]
     // if missing, return "false" to indicate it was not removed
     if (!subscription) {
-      res.result = false
-      return
+      return false
     }
     // cleanup subscription
     delete subscriptions[id]
     await subscription.destroy()
-    res.result = true
+    return true
   }
 
   function _emitSubscriptionResult(filterIdHex, value) {

test/util.js

@@ -1,8 +1,8 @@
 const EventEmitter = require('events')
 const { PollingBlockTracker } = require('@metamask/eth-block-tracker')
-const { JsonRpcEngine } = require('@metamask/json-rpc-engine')
-const { providerAsMiddleware } = require('@metamask/eth-json-rpc-middleware')
-const { providerFromEngine } = require('@metamask/eth-json-rpc-provider')
+const { JsonRpcEngineV2 } = require('@metamask/json-rpc-engine/v2')
+const { providerAsMiddlewareV2 } = require('@metamask/eth-json-rpc-middleware')
+const { InternalProvider } = require('@metamask/eth-json-rpc-provider')
 const Ganache = require('ganache')
 const createFilterMiddleware = require('../index.js')
 const createSubscriptionMiddleware = require('../subscriptionManager.js')
@@ -20,28 +20,42 @@ module.exports = {
 function createTestSetup() {
   // raw data source
   const { ganacheProvider, forceNextBlock } = createEngineFromGanache()
-  // create block trackerfilterId
+  // create block tracker
   const blockTracker = new PollingBlockTracker({
     provider: ganacheProvider,
     pollingInterval: 200,
   })
-  // create higher level
-  const engine = new JsonRpcEngine()
-  const provider = providerFromEngine(engine)
-  const request = provider.request.bind(provider);
-  // add filter middleware
-  engine.push(createFilterMiddleware({ blockTracker, provider }))
-  // add subscription middleware
-  const subscriptionManager = createSubscriptionMiddleware({ blockTracker, provider })
-  engine.push(subscriptionManager.middleware)
-  subscriptionManager.events.on('notification', (message) => engine.emit('notification', message))
-  // add data source
-  engine.push(providerAsMiddleware(ganacheProvider))
+
+  // create filter and subscription middleware
+  // these use ganacheProvider directly for data queries
+  const filterMiddleware = createFilterMiddleware({ blockTracker, provider: ganacheProvider })
+  const subscriptionManager = createSubscriptionMiddleware({ blockTracker, provider: ganacheProvider })
+
+  // create engine with all middleware
+  const engine = JsonRpcEngineV2.create({
+    middleware: [
+      filterMiddleware,
+      subscriptionManager.middleware,
+      providerAsMiddlewareV2(ganacheProvider),
+    ]
+  })
+
+  // create provider from engine with event support
+  const internalProvider = new InternalProvider({ engine })
+  const provider = Object.assign(new EventEmitter(), {
+    request: internalProvider.request.bind(internalProvider)
+  })
+
+  // forward subscription notifications
+  subscriptionManager.events.on('notification', (message) => {
+    provider.emit('notification', message)
+    provider.emit('data', null, message)
+  })
 
   // subs helper
   const subs = createSubsHelper({ provider })
 
-  return { ganacheProvider, forceNextBlock, engine, provider, request, subs, blockTracker, trackNextBlock }
+  return { ganacheProvider, forceNextBlock, provider, request: provider.request, subs, blockTracker, trackNextBlock }
 
   async function trackNextBlock() {
     return new Promise((resolve) => blockTracker.once('latest', resolve))
@@ -102,9 +116,10 @@ function createEngineFromGanache () {
 }
 
 function createEngineFromTestBlockMiddleware() {
-  const engine = new JsonRpcEngine()
   const testBlockSource = new TestBlockMiddleware()
-  engine.push(testBlockSource.createMiddleware())
+  const engine = JsonRpcEngineV2.create({
+    middleware: [testBlockSource.createMiddleware()]
+  })
   return { engine, testBlockSource }
 }