BREAKING: Token detection V2

src/ComposableController.test.ts

@@ -98,6 +98,8 @@ describe('ComposableController', () => {
       const assetContractController = new AssetsContractController({
         onPreferencesStateChange: (listener) =>
           preferencesController.subscribe(listener),
+        onNetworkStateChange: (listener) =>
+          networkController.subscribe(listener),
       });
       const collectiblesController = new CollectiblesController({
         onPreferencesStateChange: (listener) =>
@@ -152,6 +154,8 @@ describe('ComposableController', () => {
           allIgnoredTokens: {},
           suggestedAssets: [],
           tokens: [],
+          detectedTokens: [],
+          allDetectedTokens: {},
         },
         EnsController: {
           ensEntries: {},
@@ -169,7 +173,7 @@ describe('ComposableController', () => {
           ipfsGateway: 'https://ipfs.io/ipfs/',
           lostIdentities: {},
           selectedAddress: '',
-          useStaticTokenList: false,
+          useTokenDetection: false,
           useCollectibleDetection: false,
           openSeaEnabled: false,
         },
@@ -182,6 +186,8 @@ describe('ComposableController', () => {
       const assetContractController = new AssetsContractController({
         onPreferencesStateChange: (listener) =>
           preferencesController.subscribe(listener),
+        onNetworkStateChange: (listener) =>
+          networkController.subscribe(listener),
       });
       const collectiblesController = new CollectiblesController({
         onPreferencesStateChange: (listener) =>
@@ -234,14 +240,16 @@ describe('ComposableController', () => {
         ignoredCollectibles: [],
         ignoredTokens: [],
         allIgnoredTokens: {},
+        detectedTokens: [],
+        allDetectedTokens: {},
         ipfsGateway: 'https://ipfs.io/ipfs/',
         lostIdentities: {},
         network: 'loading',
         isCustomNetwork: false,
         properties: { isEIP1559Compatible: false },
         provider: { type: 'mainnet', chainId: NetworksChainId.mainnet },
         selectedAddress: '',
-        useStaticTokenList: false,
+        useTokenDetection: false,
         useCollectibleDetection: false,
         openSeaEnabled: false,
         suggestedAssets: [],

src/apis/token-service.test.ts

@@ -233,7 +233,7 @@ describe('Token service', () => {
       expect(token).toStrictEqual(sampleToken);
     });
 
-    it('should return undefined if the fetch is aborted', async () => {
+    it('should throw error if the fetch is aborted', async () => {
       const abortController = new AbortController();
       nock(TOKEN_END_POINT_API)
         .get(`/tokens/${NetworksChainId.mainnet}`)
@@ -242,49 +242,55 @@ describe('Token service', () => {
         .reply(200, sampleTokenList)
         .persist();
 
-      const fetchPromise = fetchTokenMetadata(
-        NetworksChainId.mainnet,
-        '0x514910771af9ca656af840dff83e8264ecf986ca',
-        abortController.signal,
+      await expect(async () => {
+        await fetchTokenMetadata(
+          NetworksChainId.mainnet,
+          '0x514910771af9ca656af840dff83e8264ecf986ca',
+          abortController.signal,
+        );
+        abortController.abort();
+      }).rejects.toThrow(
+        `TokenService Error: No response from fetchTokenMetadata`,
       );
-      abortController.abort();
-
-      expect(await fetchPromise).toBeUndefined();
     });
 
-    it('should return undefined if the fetch fails with a network error', async () => {
+    it('should throw error if the fetch fails with a network error', async () => {
       const { signal } = new AbortController();
       nock(TOKEN_END_POINT_API)
         .get(`/tokens/${NetworksChainId.mainnet}`)
         .replyWithError('Example network error')
         .persist();
 
-      const result = await fetchTokenMetadata(
-        NetworksChainId.mainnet,
-        '0x514910771af9ca656af840dff83e8264ecf986ca',
-        signal,
+      await expect(async () => {
+        await fetchTokenMetadata(
+          NetworksChainId.mainnet,
+          '0x514910771af9ca656af840dff83e8264ecf986ca',
+          signal,
+        );
+      }).rejects.toThrow(
+        `TokenService Error: No response from fetchTokenMetadata`,
       );
-
-      expect(result).toBeUndefined();
     });
 
-    it('should return undefined if the fetch fails with an unsuccessful status code', async () => {
+    it('should throw error if the fetch fails with an unsuccessful status code', async () => {
       const { signal } = new AbortController();
       nock(TOKEN_END_POINT_API)
         .get(`/tokens/${NetworksChainId.mainnet}`)
         .reply(500)
         .persist();
 
-      const result = await fetchTokenMetadata(
-        NetworksChainId.mainnet,
-        '0x514910771af9ca656af840dff83e8264ecf986ca',
-        signal,
+      await expect(async () => {
+        await fetchTokenMetadata(
+          NetworksChainId.mainnet,
+          '0x514910771af9ca656af840dff83e8264ecf986ca',
+          signal,
+        );
+      }).rejects.toThrow(
+        `TokenService Error: No response from fetchTokenMetadata`,
       );
-
-      expect(result).toBeUndefined();
     });
 
-    it('should return undefined if the fetch fails with a timeout', async () => {
+    it('should throw error if the fetch fails with a timeout', async () => {
       const { signal } = new AbortController();
       nock(TOKEN_END_POINT_API)
         .get(`/tokens/${NetworksChainId.mainnet}`)
@@ -293,14 +299,28 @@ describe('Token service', () => {
         .reply(200, sampleTokenList)
         .persist();
 
-      const result = await fetchTokenMetadata(
-        NetworksChainId.mainnet,
-        '0x514910771af9ca656af840dff83e8264ecf986ca',
-        signal,
-        { timeout: ONE_MILLISECOND },
+      await expect(async () => {
+        await fetchTokenMetadata(
+          NetworksChainId.mainnet,
+          '0x514910771af9ca656af840dff83e8264ecf986ca',
+          signal,
+          { timeout: ONE_MILLISECOND },
+        );
+      }).rejects.toThrow(
+        `TokenService Error: No response from fetchTokenMetadata`,
       );
-
-      expect(result).toBeUndefined();
     });
   });
+
+  it('should call the tokens api and return undefined', async () => {
+    const { signal } = new AbortController();
+    nock(TOKEN_END_POINT_API)
+      .get(`/tokens/${NetworksChainId.mainnet}`)
+      .reply(404, undefined)
+      .persist();
+
+    const tokens = await fetchTokenList(NetworksChainId.mainnet, signal);
+
+    expect(tokens).toBeUndefined();
+  });
 });

src/apis/token-service.ts

@@ -63,18 +63,18 @@ export async function fetchTokenList(
  * @param options.timeout - The fetch timeout.
  * @returns The token metadata, or `undefined` if the request was cancelled.
  */
-export async function fetchTokenMetadata(
+export async function fetchTokenMetadata<T>(
   chainId: string,
   tokenAddress: string,
   abortSignal: AbortSignal,
   { timeout = defaultTimeout } = {},
-): Promise<unknown> {
+): Promise<T> {
   const tokenMetadataURL = getTokenMetadataURL(chainId, tokenAddress);
   const response = await queryApi(tokenMetadataURL, abortSignal, timeout);
   if (response) {
-    return parseJsonResponse(response);
+    return parseJsonResponse(response) as Promise<T>;
   }
-  return undefined;
+  throw new Error(`TokenService Error: No response from fetchTokenMetadata`);
 }
 
 /**

src/assets/AssetsContractController.test.ts

@@ -1,7 +1,12 @@
 import HttpProvider from 'ethjs-provider-http';
 import { IPFS_DEFAULT_GATEWAY_URL } from '../constants';
+import { SupportedTokenDetectionNetworks } from '../util';
 import { PreferencesController } from '../user/PreferencesController';
-import { AssetsContractController } from './AssetsContractController';
+import { NetworkController } from '../network/NetworkController';
+import {
+  AssetsContractController,
+  MISSING_PROVIDER_ERROR,
+} from './AssetsContractController';
 
 const MAINNET_PROVIDER = new HttpProvider(
   'https://mainnet.infura.io/v3/341eacb578dd44a1a049cbc5f6fd4035',
@@ -19,29 +24,36 @@ const TEST_ACCOUNT_PUBLIC_ADDRESS =
 describe('AssetsContractController', () => {
   let assetsContract: AssetsContractController;
   let preferences: PreferencesController;
+  let network: NetworkController;
+
   beforeEach(() => {
     preferences = new PreferencesController();
+    network = new NetworkController();
     assetsContract = new AssetsContractController({
       onPreferencesStateChange: (listener) => preferences.subscribe(listener),
+      onNetworkStateChange: (listener) => network.subscribe(listener),
     });
   });
 
   it('should set default config', () => {
     expect(assetsContract.config).toStrictEqual({
+      chainId: SupportedTokenDetectionNetworks.mainnet,
       ipfsGateway: IPFS_DEFAULT_GATEWAY_URL,
       provider: undefined,
     });
   });
 
   it('should update the ipfsGateWay config value when this value is changed in the preferences controller', () => {
     expect(assetsContract.config).toStrictEqual({
+      chainId: SupportedTokenDetectionNetworks.mainnet,
       ipfsGateway: IPFS_DEFAULT_GATEWAY_URL,
       provider: undefined,
     });
 
     preferences.setIpfsGateway('newIPFSGateWay');
     expect(assetsContract.config).toStrictEqual({
       ipfsGateway: 'newIPFSGateWay',
+      chainId: SupportedTokenDetectionNetworks.mainnet,
       provider: undefined,
     });
   });
@@ -52,6 +64,24 @@ describe('AssetsContractController', () => {
     );
   });
 
+  it('should throw missing provider error when getting ERC-20 token balance when missing provider', async () => {
+    assetsContract.configure({ provider: undefined });
+    await expect(
+      async () =>
+        await assetsContract.getERC20BalanceOf(
+          ERC20_UNI_ADDRESS,
+          TEST_ACCOUNT_PUBLIC_ADDRESS,
+        ),
+    ).rejects.toThrow(MISSING_PROVIDER_ERROR);
+  });
+
+  it('should throw missing provider error when getting ERC-20 token decimal when missing provider', async () => {
+    assetsContract.configure({ provider: undefined });
+    await expect(
+      async () => await assetsContract.getERC20TokenDecimals(ERC20_UNI_ADDRESS),
+    ).rejects.toThrow(MISSING_PROVIDER_ERROR);
+  });
+
   it('should get balance of ERC-20 token contract correctly', async () => {
     assetsContract.configure({ provider: MAINNET_PROVIDER });
     const UNIBalance = await assetsContract.getERC20BalanceOf(
@@ -76,6 +106,17 @@ describe('AssetsContractController', () => {
     expect(tokenId).not.toStrictEqual(0);
   });
 
+  it('should throw missing provider error when getting ERC-721 token standard and details when missing provider', async () => {
+    assetsContract.configure({ provider: undefined });
+    await expect(
+      async () =>
+        await assetsContract.getTokenStandardAndDetails(
+          ERC20_UNI_ADDRESS,
+          TEST_ACCOUNT_PUBLIC_ADDRESS,
+        ),
+    ).rejects.toThrow(MISSING_PROVIDER_ERROR);
+  });
+
   it('should get ERC-721 collectible tokenURI correctly', async () => {
     assetsContract.configure({ provider: MAINNET_PROVIDER });
     const tokenId = await assetsContract.getERC721TokenURI(
@@ -138,6 +179,20 @@ describe('AssetsContractController', () => {
     expect(balances[ERC20_DAI_ADDRESS]).not.toStrictEqual(0);
   });
 
+  it('should throw missing provider error when transfering single ERC-1155 when missing provider', async () => {
+    assetsContract.configure({ provider: undefined });
+    await expect(
+      async () =>
+        await assetsContract.transferSingleERC1155(
+          ERC1155_ADDRESS,
+          TEST_ACCOUNT_PUBLIC_ADDRESS,
+          TEST_ACCOUNT_PUBLIC_ADDRESS,
+          ERC1155_ID,
+          '1',
+        ),
+    ).rejects.toThrow(MISSING_PROVIDER_ERROR);
+  });
+
   it('should get the balance of a ERC-1155 collectible for a given address', async () => {
     assetsContract.configure({ provider: MAINNET_PROVIDER });
     const balance = await assetsContract.getERC1155BalanceOf(