Added multichain api notifications

app/scripts/lib/multichain-api/multicainSubscriptionManager.test.ts

@@ -0,0 +1,75 @@
+import { JsonRpcMiddleware } from 'json-rpc-engine';
+import MultichainSubscriptionManager, { createMultichainMiddlewareManager } from './multichainSubscriptionManager';
+
+const newHeadsNotificationMock = {
+  method: 'eth_subscription',
+  params: {
+    result: {
+      difficulty: '0x15d9223a23aa',
+      extraData: '0xd983010305844765746887676f312e342e328777696e646f7773',
+      gasLimit: '0x47e7c4',
+      gasUsed: '0x38658',
+      logsBloom:
+        '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      miner: '0xf8b483dba2c3b7176a3da549ad41a48bb3121069',
+      nonce: '0x084149998194cc5f',
+      number: '0x1348c9',
+      parentHash:
+        '0x7736fab79e05dc611604d22470dadad26f56fe494421b5b333de816ce1f25701',
+      receiptRoot:
+        '0x2fab35823ad00c7bb388595cb46652fe7886e00660a01e867824d3dceb1c8d36',
+      sha3Uncles:
+        '0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347',
+      stateRoot:
+        '0xb3346685172db67de536d8765c43c31009d0eb3bd9c501c9be3229203f15f378',
+      timestamp: '0x56ffeff8',
+    },
+  },
+};
+
+describe('multichainSubscriptionManager', () => {
+  it('should subscribe to a chain', (done) => {
+    const scope = 'eip155:1';
+    const mockFindNetworkClientIdByChainId = jest.fn()
+    const mockGetNetworkClientById = jest.fn().mockImplementation(() => ({
+      blockTracker: {},
+      provider: {},
+    }));
+    const subscriptionManager = new MultichainSubscriptionManager({
+      findNetworkClientIdByChainId: mockFindNetworkClientIdByChainId,
+      getNetworkClientById: mockGetNetworkClientById,
+    });
+    subscriptionManager.subscribe(scope);
+    subscriptionManager.on('notification', (notification: any) => {
+      expect(notification).toMatchObject({
+        method: "wallet_invokeMethod",
+        params: {
+          scope,
+          request: newHeadsNotificationMock,
+        }
+      });
+      done();
+    });
+    subscriptionManager.onNotification(scope, newHeadsNotificationMock);
+  });
+});
+describe('multichainMiddlewareManager', () => {
+  it('should add middleware and get called for the scope', () => {
+    const multichainMiddlewareManager = createMultichainMiddlewareManager();
+    const middlewareSpy = jest.fn();
+    multichainMiddlewareManager.addMiddleware('eip155:1', middlewareSpy);
+    multichainMiddlewareManager.middleware({scope: 'eip155:1'}, {}, () => { }, () => {});
+    expect(middlewareSpy).toHaveBeenCalled();
+  })
+  it('should remove middleware', () => {
+    const multichainMiddlewareManager = createMultichainMiddlewareManager();
+    const middlewareMock = jest.fn();
+    (middlewareMock as unknown as {destroy: () => void}).destroy = jest.fn();
+    const scope = 'eip155:1';
+    multichainMiddlewareManager.addMiddleware(scope, middlewareMock);
+    multichainMiddlewareManager.removeMiddleware(scope);
+    expect(() => {
+      multichainMiddlewareManager.middleware({scope}, {}, () => { }, () => {});
+    }).toThrow();
+  })
+});

app/scripts/lib/multichain-api/multichainSubscriptionManager.ts

@@ -0,0 +1,109 @@
+import {
+  NetworkControllerFindNetworkClientIdByChainIdAction,
+  NetworkControllerGetNetworkClientByIdAction,
+} from '@metamask/network-controller';
+import SafeEventEmitter from '@metamask/safe-event-emitter';
+import { parseCaipChainId } from '@metamask/utils';
+import { toHex } from '@metamask/controller-utils';
+import { Scope } from './scope';
+
+const createSubscriptionManager = require('@metamask/eth-json-rpc-filters/subscriptionManager');
+
+type MultichainSubscriptionManagerOptions = {
+  findNetworkClientIdByChainId: NetworkControllerFindNetworkClientIdByChainIdAction['handler'];
+  getNetworkClientById: NetworkControllerGetNetworkClientByIdAction['handler'];
+};
+
+export default class MultichainSubscriptionManager extends SafeEventEmitter {
+  private subscriptionsByChain: { [scope: string]: unknown };
+
+  private findNetworkClientIdByChainId: NetworkControllerFindNetworkClientIdByChainIdAction['handler'];
+
+  private getNetworkClientById: NetworkControllerGetNetworkClientByIdAction['handler'];
+
+  private subscriptionManagerByChain: { [scope: string]: any };
+
+  constructor(options: MultichainSubscriptionManagerOptions) {
+    super();
+    this.findNetworkClientIdByChainId = options.findNetworkClientIdByChainId;
+    this.getNetworkClientById = options.getNetworkClientById;
+    this.subscriptionManagerByChain = {};
+    this.subscriptionsByChain = {};
+  }
+
+  onNotification(scope: Scope, message: any) {
+    this.emit('notification', {
+      method: 'wallet_invokeMethod',
+      params: {
+        scope,
+        request: message,
+      },
+    });
+  }
+
+  subscribe(scope: Scope) {
+    const networkClientId = this.findNetworkClientIdByChainId(
+      toHex(parseCaipChainId(scope).reference),
+    );
+    const networkClient = this.getNetworkClientById(networkClientId);
+    const subscriptionManager = createSubscriptionManager({
+      blockTracker: networkClient.blockTracker,
+      provider: networkClient.provider,
+    });
+    this.subscriptionManagerByChain[scope] = subscriptionManager;
+    this.subscriptionsByChain[scope] = this.onNotification.bind(this, scope);
+    subscriptionManager.events.on(
+      'notification',
+      this.subscriptionsByChain[scope],
+    );
+    return subscriptionManager;
+  }
+
+  unsubscribe(scope: Scope) {
+    const subscriptionManager = this.subscriptionManagerByChain[scope];
+    if (subscriptionManager) {
+      subscriptionManager.events.off(
+        'notification',
+        this.subscriptionsByChain[scope],
+      );
+      subscriptionManager.destroy();
+    }
+    delete this.subscriptionManagerByChain[scope];
+    delete this.subscriptionsByChain[scope];
+  }
+
+  unsubscribeAll() {
+    Object.keys(this.subscriptionManagerByChain).forEach((scope) => {
+      this.unsubscribe(scope);
+    });
+  }
+}
+
+// per scope middleware to handle legacy middleware
+export const createMultichainMiddlewareManager = () => {
+  const middlewaresByScope: Record<Scope, any> = {};
+  const removeMiddleware = (scope: Scope) => {
+    const middleware = middlewaresByScope[scope];
+    middleware.destroy();
+    delete middlewaresByScope[scope];
+  };
+
+  const removeAllMiddleware = () => {
+    Object.keys(middlewaresByScope).forEach((scope) => {
+      removeMiddleware(scope);
+    });
+  };
+
+  const addMiddleware = (scope: Scope, middleware: any) => {
+    middlewaresByScope[scope] = middleware;
+  };
+
+  return {
+    middleware: (req: any, res: any, next: any, end: any) => {
+      return middlewaresByScope[req.scope](req, res, next, end);
+    },
+    addMiddleware,
+    removeMiddleware,
+    removeAllMiddleware,
+  };
+};

app/scripts/lib/multichain-api/provider-authorize.js

@@ -55,6 +55,7 @@ export async function providerAuthorizeHandler(req, res, _next, end, hooks) {
       ),
     );
   }
+  console.log(' got to before sessionid');
 
   const sessionId = '0xdeadbeef';
 
@@ -72,6 +73,7 @@ export async function providerAuthorizeHandler(req, res, _next, end, hooks) {
         [RestrictedMethods.eth_accounts]: {},
       },
     );
+    console.log(' got to after requestPermissions');
     const permittedAccounts = getAccountsFromPermission(subjectPermission);
     const { flattenedRequiredScopes, flattenedOptionalScopes } = processScopes(
       requiredScopes,
@@ -113,14 +115,35 @@ export async function providerAuthorizeHandler(req, res, _next, end, hooks) {
       },
     });
 
+    const mergedScopes = mergeScopes(
+      flattenedRequiredScopes,
+      flattenedOptionalScopes,
+    );
+
+    // clear per scope middleware
+    hooks.multichainMiddlewareManager.removeAllMiddleware();
+    hooks.multichainSubscriptionManager.unsubscribeAll();
+
+    // if the eth_subscription notification is in the scope and eth_subscribe is in the methods
+    // then get the subscriptionManager going for that scope
+    Object.entries(mergedScopes).forEach(([scope, scopeObject]) => {
+      if (
+        scopeObject.notifications.includes('eth_subscription') &&
+        scopeObject.methods.includes('eth_subscribe')
+      ) {
+        const subscriptionManager = hooks.subscriptionManager.subscribe(scope);
+        hooks.multichainMiddlewareManager.addMiddleware(
+          scope,
+          subscriptionManager.middleware,
+        );
+      }
+    });
+
     // TODO: metrics/tracking after approval
 
     res.result = {
       sessionId,
-      sessionScopes: mergeScopes(
-        flattenedRequiredScopes,
-        flattenedOptionalScopes,
-      ),
+      sessionScopes: mergedScopes,
       sessionProperties,
     };
     return end();

app/scripts/lib/multichain-api/provider-authorize.test.js

@@ -58,6 +58,16 @@ const createMockedHandler = () => {
   const response = {};
   const handler = (request) =>
     providerAuthorizeHandler(request, response, next, end, {
+      multichainMiddlewareManager: {
+        addMiddleware: jest.fn(),
+        removeMiddleware: jest.fn(),
+        removeAllMiddleware: jest.fn(),
+      },
+      multichainSubscriptionManager: {
+        subscribe: jest.fn(),
+        unsubscribe: jest.fn(),
+        unsubscribeAll: jest.fn(),
+      },
       findNetworkClientIdByChainId,
       requestPermissions,
       grantPermissions,
@@ -295,6 +305,7 @@ describe('provider_authorize', () => {
       },
     });
     await handler(baseRequest);
+    console.log('RESPONSE ===', response);
 
     expect(response.result).toStrictEqual({
       sessionId: '0xdeadbeef',

app/scripts/lib/multichain-api/provider-request.js

@@ -75,6 +75,7 @@ export async function providerRequestHandler(
   }
 
   Object.assign(request, {
+    scope,
     networkClientId,
     method: wrappedRequest.method,
     params: wrappedRequest.params,

app/scripts/lib/multichain-api/provider-request.test.js

@@ -154,6 +154,7 @@ describe('provider_request', () => {
 
       await handler(request);
       expect(request).toStrictEqual({
+        scope: 'eip155:1',
         origin: 'http://test.com',
         networkClientId: 'mainnet',
         method: 'eth_call',
@@ -223,6 +224,7 @@ describe('provider_request', () => {
       };
       await handler(walletRequest);
       expect(walletRequest).toStrictEqual({
+        scope: 'wallet',
         origin: 'http://test.com',
         networkClientId: 'selectedNetworkClientId',
         method: 'wallet_watchAsset',

app/scripts/metamask-controller.js

@@ -337,6 +337,9 @@ import {
 } from './lib/multichain-api/caip25permissions';
 import { multichainMethodCallValidatorMiddleware } from './lib/multichain-api/multichainMethodCallValidator';
 import { decodeTransactionData } from './lib/transaction/decode/util';
+import MultichainSubscriptionManager, {
+  createMultichainMiddlewareManager,
+} from './lib/multichain-api/multichainSubscriptionManager';
 
 export const METAMASK_CONTROLLER_EVENTS = {
   // Fired after state changes that impact the extension badge (unapproved msg count)
@@ -532,6 +535,19 @@ export default class MetamaskController extends EventEmitter {
       trackMetaMetricsEvent: (...args) =>
         this.metaMetricsController.trackEvent(...args),
     });
+
+    this.multichainSubscriptionManager = new MultichainSubscriptionManager({
+      getNetworkClientById: this.networkController.getNetworkClientById.bind(
+        this.networkController,
+      ),
+      findNetworkClientIdByChainId:
+        this.networkController.findNetworkClientIdByChainId.bind(
+          this.networkController,
+        ),
+    });
+
+    this.multichainMiddlewareManager = createMultichainMiddlewareManager();
+
     this.networkController.initializeProvider();
     this.provider =
       this.networkController.getProviderAndBlockTracker().provider;
@@ -4551,6 +4567,10 @@ export default class MetamaskController extends EventEmitter {
         config.type !== networkConfigurationId,
     );
 
+    const scope = `eip155:${parseInt(chainId, 16)}`;
+    this.multichainSubscriptionManager.unsubscribe(scope);
+    this.multichainMiddlewareManager.removeMiddleware(scope);
+
     // if this network configuration is only one for a given chainId
     // remove all permissions for that chainId
     if (!hasOtherConfigsForChainId) {
@@ -5602,6 +5622,8 @@ export default class MetamaskController extends EventEmitter {
       createScaffoldMiddleware({
         [MESSAGE_TYPE.PROVIDER_AUTHORIZE]: (request, response, next, end) => {
           return providerAuthorizeHandler(request, response, next, end, {
+            multichainMiddlewareManager: this.multichainMiddlewareManager,
+            multichainSubscriptionManager: this.multichainSubscriptionManager,
             grantPermissions: this.permissionController.grantPermissions.bind(
               this.permissionController,
             ),
@@ -5720,11 +5742,11 @@ export default class MetamaskController extends EventEmitter {
             },
           ),
         // TODO remove this hook
-        requestPermissionsForOrigin:
-          this.permissionController.requestPermissions.bind(
-            this.permissionController,
-            { origin },
-          ),
+        // requestPermissionsForOrigin:
+        //   this.permissionController.requestPermissions.bind(
+        //     this.permissionController,
+        //     { origin },
+        //   ),
         getCaveat: ({ target, caveatType }) => {
           try {
             return this.permissionController.getCaveat(
@@ -5795,6 +5817,12 @@ export default class MetamaskController extends EventEmitter {
 
     engine.push(this.metamaskMiddleware);
 
+    this.multichainSubscriptionManager.on('notification', (message) =>
+      engine.emit('notification', message),
+    );
+
+    engine.push(this.multichainMiddlewareManager.middleware);
+
     engine.push((req, res, _next, end) => {
       const { provider } = this.networkController.getNetworkClientById(
         req.networkClientId,