metamask-extension/app/scripts/controllers/network/network-controller.test.js

import nock from 'nock';
import { deferredPromise } from '../../lib/util';
import NetworkController, { NETWORK_EVENTS } from './network-controller';

/**
 * Construct a successful RPC response.
 *
 * @param {any} result - The RPC result to return.
 * @returns A successful RPC response with the specified result.
 */
function constructSuccessfulRpcResponse(result) {
  return {
    id: 1,
    jsonrpc: '2.0',
    result,
  };
}

// Example block taken from Ethereum Mainnet that has been updated to match the
// pre-EIP-1559 format (i.e. it doesn't have the `baseFeePerGas` property).
const PRE_1559_BLOCK = {
  difficulty: '0x0',
  extraData: '0x',
  gasLimit: '0x1c9c380',
  gasUsed: '0x598c9b',
  hash: '0xfb2086eb924ffce4061f94c3b65f303e0351f8e7deff185fe1f5e9001ff96f63',
  logsBloom:
    '0x7034820113921800018e8070900006316040002225c04a0624110010841018a2109040401004112a4c120f00220a2119020000714b143a04004106120130a8450080433129401068ed22000a54a48221a1020202524204045421b883882530009a1800b08a1309408008828403010d530440001a40003c0006240291008c0404c211610c690b00f1985e000009c02503240040010989c01cf2806840043815498e90012103e06084051542c0094002494008044c24a0a13281e0009601481073010800130402464202212202a8088210442a8ec81b080430075629e60a00a082005a3988400940a4009012a204011a0018a00903222a60420428888144210802',
  miner: '0xffee087852cb4898e6c3532e776e68bc68b1143b',
  mixHash: '0xb17ba50cd7261e77a213fb75704dcfd8a28fbcd78d100691a112b7cc2893efa2',
  nonce: '0x0000000000000000',
  number: '0x2', // number set to "2" to simplify tests
  parentHash:
    '0x31406d1bf1a2ca12371ce5b3ecb20568d6a8b9bf05b49b71b93ba33f317d5a82',
  receiptsRoot:
    '0x5ba97ece1afbac2a8fe0344f9022fe808342179b26ea3ecc2e0b8c4b46b7f8cd',
  sha3Uncles:
    '0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347',
  size: '0x70f4',
  stateRoot:
    '0x36bfb7ca106d41c4458292669126e091011031c5af612dee1c2e6424ef92b080',
  timestamp: '0x639b6d9b',
  totalDifficulty: '0xc70d815d562d3cfa955',
  transactions: [
    // reduced to a single transaction to make fixture less verbose
    '0x2761e939dc822f64141bd00bc7ef8cee16201af10e862469212396664cee81ce',
  ],
  transactionsRoot:
    '0x98bbdfbe1074bc3aa72a77a281f16d6ba7e723d68f15937d80954fb34d323369',
  uncles: [],
};
// Example block taken from Ethereum Mainnet post-EIP-1559
const BLOCK = {
  ...PRE_1559_BLOCK,
  baseFeePerGas: '0x63c498a46',
};

const defaultControllerOptions = {
  infuraProjectId: 'foo',
};

/**
 * Builds a controller based on the given options, and calls the given function
 * with that controller.
 *
 * @param args - Either a function, or constructor options + a function. The
 * function will be called with the built controller.
 * @returns Whatever the callback returns.
 */
async function withController(...args) {
  const [constructorArgs, fn] = args.length === 2 ? args : [{}, args[0]];
  const controller = new NetworkController({
    ...defaultControllerOptions,
    ...constructorArgs,
  });
  try {
    return await fn({ controller });
  } finally {
    await controller.destroy();
  }
}

describe('NetworkController', () => {
  describe('controller', () => {
    let latestBlock;

    beforeEach(() => {
      latestBlock = BLOCK;
      nock('http://localhost:8545')
        .persist()
        .post(/.*/u)
        .reply(200, () =>
          JSON.stringify(constructSuccessfulRpcResponse(latestBlock)),
        );
      nock('https://mainnet.infura.io')
        .persist()
        .post('/v3/foo')
        .reply(200, () =>
          JSON.stringify(constructSuccessfulRpcResponse(latestBlock)),
        );
    });

    afterEach(() => {
      nock.cleanAll();
    });

    describe('#provider', () => {
      it('provider should be updatable without reassignment', async () => {
        await withController(async ({ controller }) => {
          await controller.initializeProvider();
          const providerProxy =
            controller.getProviderAndBlockTracker().provider;
          expect(providerProxy.test).toBeUndefined();

          providerProxy.setTarget({ test: true });

          expect(providerProxy.test).toStrictEqual(true);
        });
      });
    });

    describe('destroy', () => {
      it('should not throw if called before initialization', async () => {
        const controller = new NetworkController(defaultControllerOptions);
        await expect(controller.destroy()).resolves.toBe(undefined);
      });

      it('should stop the block tracker for the current selected network', async () => {
        await withController(async ({ controller }) => {
          await controller.initializeProvider();
          const { blockTracker } = controller.getProviderAndBlockTracker();
          // The block tracker starts running after a listener is attached
          blockTracker.addListener('latest', () => {
            // do nothing
          });
          expect(blockTracker.isRunning()).toBe(true);

          await controller.destroy();

          expect(blockTracker.isRunning()).toBe(false);
        });
      });
    });

    describe('#getNetworkState', () => {
      it('should return "loading" when uninitialized', async () => {
        await withController(async ({ controller }) => {
          const networkState = controller.getNetworkState();
          expect(networkState).toStrictEqual('loading');
        });
      });
    });

    describe('#setProviderType', () => {
      it('should update provider.type', async () => {
        await withController(async ({ controller }) => {
          await controller.initializeProvider();
          controller.setProviderType('mainnet');
          const { type } = controller.getProviderConfig();
          expect(type).toStrictEqual('mainnet');
        });
      });

      it('should set the network to loading', async () => {
        await withController(async ({ controller }) => {
          await controller.initializeProvider();

          controller.setProviderType('mainnet');
          const { promise: networkIdChanged, resolve } = deferredPromise();
          controller.networkStore.subscribe(resolve);

          expect(controller.networkStore.getState()).toBe('loading');
          await networkIdChanged;
          expect(controller.networkStore.getState()).toBe('1');
        });
      });
    });

    describe('#getEIP1559Compatibility', () => {
      it('should return false when baseFeePerGas is not in the block header', async () => {
        await withController(async ({ controller }) => {
          latestBlock = PRE_1559_BLOCK;
          await controller.initializeProvider();
          const supportsEIP1559 = await controller.getEIP1559Compatibility();
          expect(supportsEIP1559).toStrictEqual(false);
        });
      });

      it('should return true when baseFeePerGas is in block header', async () => {
        await withController(async ({ controller }) => {
          await controller.initializeProvider();
          const supportsEIP1559 = await controller.getEIP1559Compatibility();
          expect(supportsEIP1559).toStrictEqual(true);
        });
      });

      it('should store EIP1559 support in state to reduce calls to _getLatestBlock', async () => {
        await withController(async ({ controller }) => {
          await controller.initializeProvider();
          await controller.getEIP1559Compatibility();
          const supportsEIP1559 = await controller.getEIP1559Compatibility();
          expect(supportsEIP1559).toStrictEqual(true);
        });
      });

      it('should clear stored EIP1559 support when changing networks', async () => {
        await withController(async ({ controller }) => {
          await controller.initializeProvider();
          await controller.getEIP1559Compatibility();
          expect(controller.networkDetails.getState().EIPS[1559]).toStrictEqual(
            true,
          );
          latestBlock = PRE_1559_BLOCK;
          await new Promise((resolve) => {
            controller.on(NETWORK_EVENTS.NETWORK_DID_CHANGE, () => {
              resolve();
            });
            controller.setProviderType('mainnet');
          });
          expect(
            controller.networkDetails.getState().EIPS[1559],
          ).toBeUndefined();
          await controller.getEIP1559Compatibility();
          expect(controller.networkDetails.getState().EIPS[1559]).toStrictEqual(
            false,
          );
        });
      });
    });
  });
});