Update 'token contract address' -> 'token address'

mcmire · mcmire · commit 1e01defd9b54 · 2023-12-12T12:25:29.000-07:00
A recent change to update TokenRatesController from the CoinGecko API to
our own API added code which refers to "token contract addresses". While
this is a more accurate name for the hexadecimal string you can use to
refer to a token, we consistently use the name "token address" in the
code rather than "token contract address", so update these references to
be consistent with existing code.
diff --git a/packages/assets-controllers/src/TokenRatesController.test.ts b/packages/assets-controllers/src/TokenRatesController.test.ts
@@ -9,7 +9,7 @@ import { advanceTime } from '../../../tests/helpers';
 import type {
   AbstractTokenPricesService,
   TokenPrice,
-  TokenPricesByTokenContractAddress,
+  TokenPricesByTokenAddress,
 } from './token-prices-service/abstract-token-prices-service';
 import type { TokenBalancesState } from './TokenBalancesController';
 import { TokenRatesController } from './TokenRatesController';
@@ -1691,12 +1691,12 @@ describe('TokenRatesController', () => {
         fetchTokenPrices: jest.fn().mockResolvedValue({
           [tokenAddresses[0]]: {
             currency: 'ETH',
-            tokenContractAddress: tokenAddresses[0],
+            tokenAddress: tokenAddresses[0],
             value: 0.001,
           },
           [tokenAddresses[1]]: {
             currency: 'ETH',
-            tokenContractAddress: tokenAddresses[1],
+            tokenAddress: tokenAddresses[1],
             value: 0.002,
           },
         }),
@@ -1760,12 +1760,12 @@ describe('TokenRatesController', () => {
           fetchTokenPrices: jest.fn().mockResolvedValue({
             [tokenAddresses[0]]: {
               currency: 'ETH',
-              tokenContractAddress: tokenAddresses[0],
+              tokenAddress: tokenAddresses[0],
               value: 0.001,
             },
             [tokenAddresses[1]]: {
               currency: 'ETH',
-              tokenContractAddress: tokenAddresses[1],
+              tokenAddress: tokenAddresses[1],
               value: 0.002,
             },
           }),
@@ -1827,12 +1827,12 @@ describe('TokenRatesController', () => {
         fetchTokenPrices: jest.fn().mockResolvedValue({
           [tokenAddresses[0]]: {
             currency: 'ETH',
-            tokenContractAddress: tokenAddresses[0],
+            tokenAddress: tokenAddresses[0],
             value: 0.001,
           },
           [tokenAddresses[1]]: {
             currency: 'ETH',
-            tokenContractAddress: tokenAddresses[1],
+            tokenAddress: tokenAddresses[1],
             value: 0.002,
           },
         }),
@@ -1909,12 +1909,12 @@ describe('TokenRatesController', () => {
         fetchTokenPrices: jest.fn().mockResolvedValue({
           [tokenAddresses[0]]: {
             currency: 'ETH',
-            tokenContractAddress: tokenAddresses[0],
+            tokenAddress: tokenAddresses[0],
             value: 0.001,
           },
           [tokenAddresses[1]]: {
             currency: 'ETH',
-            tokenContractAddress: tokenAddresses[1],
+            tokenAddress: tokenAddresses[1],
             value: 0.002,
           },
         }),
@@ -2170,31 +2170,31 @@ function buildMockTokenPricesService(
  * price of each given token is incremented by one.
  *
  * @param args - The arguments to this function.
- * @param args.tokenContractAddresses - The token contract addresses.
+ * @param args.tokenAddresses - The token addresses.
  * @param args.currency - The currency.
  * @returns The token prices.
  */
 async function fetchTokenPricesWithIncreasingPriceForEachToken<
   TokenAddress extends Hex,
   Currency extends string,
 >({
-  tokenContractAddresses,
+  tokenAddresses,
   currency,
 }: {
-  tokenContractAddresses: TokenAddress[];
+  tokenAddresses: TokenAddress[];
   currency: Currency;
 }) {
-  return tokenContractAddresses.reduce<
-    Partial<TokenPricesByTokenContractAddress<TokenAddress, Currency>>
-  >((obj, tokenContractAddress, i) => {
+  return tokenAddresses.reduce<
+    Partial<TokenPricesByTokenAddress<TokenAddress, Currency>>
+  >((obj, tokenAddress, i) => {
     const tokenPrice: TokenPrice<TokenAddress, Currency> = {
-      tokenContractAddress,
+      tokenAddress,
       value: (i + 1) / 1000,
       currency,
     };
     return {
       ...obj,
-      [tokenContractAddress]: tokenPrice,
+      [tokenAddress]: tokenPrice,
     };
-  }, {}) as TokenPricesByTokenContractAddress<TokenAddress, Currency>;
+  }, {}) as TokenPricesByTokenAddress<TokenAddress, Currency>;
 }
diff --git a/packages/assets-controllers/src/TokenRatesController.ts b/packages/assets-controllers/src/TokenRatesController.ts
@@ -355,13 +355,13 @@ export class TokenRatesController extends PollingControllerV1<
       return;
     }
 
-    const tokenContractAddresses = this.#getTokenAddresses(chainId);
-    if (tokenContractAddresses.length === 0) {
+    const tokenAddresses = this.#getTokenAddresses(chainId);
+    if (tokenAddresses.length === 0) {
       return;
     }
 
     const newContractExchangeRates = await this.#fetchAndMapExchangeRates({
-      tokenContractAddresses,
+      tokenAddresses,
       chainId,
       nativeCurrency,
     });
@@ -404,42 +404,42 @@ export class TokenRatesController extends PollingControllerV1<
    * exchange rate between the known currency and desired currency.
    *
    * @param args - The arguments to this function.
-   * @param args.tokenContractAddresses - Contract addresses for tokens.
+   * @param args.tokenAddresses - Addresses for tokens.
    * @param args.chainId - The EIP-155 ID of the chain where the tokens live.
    * @param args.nativeCurrency - The native currency in which to request
    * exchange rates.
-   * @returns A map from token contract address to its exchange rate in the
-   * native currency, or an empty map if no exchange rates can be obtained for
-   * the chain ID.
+   * @returns A map from token address to its exchange rate in the native
+   * currency, or an empty map if no exchange rates can be obtained for the
+   * chain ID.
    */
   async #fetchAndMapExchangeRates({
-    tokenContractAddresses,
+    tokenAddresses,
     chainId,
     nativeCurrency,
   }: {
-    tokenContractAddresses: Hex[];
+    tokenAddresses: Hex[];
     chainId: Hex;
     nativeCurrency: string;
   }): Promise<ContractExchangeRates> {
     if (!this.#tokenPricesService.validateChainIdSupported(chainId)) {
-      return tokenContractAddresses.reduce((obj, tokenContractAddress) => {
+      return tokenAddresses.reduce((obj, tokenAddress) => {
         return {
           ...obj,
-          [tokenContractAddress]: undefined,
+          [tokenAddress]: undefined,
         };
       }, {});
     }
 
     if (this.#tokenPricesService.validateCurrencySupported(nativeCurrency)) {
       return await this.#fetchAndMapExchangeRatesForSupportedNativeCurrency({
-        tokenContractAddresses,
+        tokenAddresses,
         chainId,
         nativeCurrency,
       });
     }
 
     return await this.#fetchAndMapExchangeRatesForUnsupportedNativeCurrency({
-      tokenContractAddresses,
+      tokenAddresses,
       nativeCurrency,
     });
   }
@@ -463,34 +463,34 @@ export class TokenRatesController extends PollingControllerV1<
    * chain. Ensures that token addresses are checksum addresses.
    *
    * @param args - The arguments to this function.
-   * @param args.tokenContractAddresses - Contract addresses for tokens.
+   * @param args.tokenAddresses - Addresses for tokens.
    * @param args.chainId - The EIP-155 ID of the chain where the tokens live.
    * @param args.nativeCurrency - The native currency in which to request
    * prices.
    * @returns A map of the token addresses (as checksums) to their prices in the
    * native currency.
    */
   async #fetchAndMapExchangeRatesForSupportedNativeCurrency({
-    tokenContractAddresses,
+    tokenAddresses,
     chainId,
     nativeCurrency,
   }: {
-    tokenContractAddresses: Hex[];
+    tokenAddresses: Hex[];
     chainId: Hex;
     nativeCurrency: string;
   }): Promise<ContractExchangeRates> {
-    const tokenPricesByTokenContractAddress =
+    const tokenPricesByTokenAddress =
       await this.#tokenPricesService.fetchTokenPrices({
-        tokenContractAddresses,
+        tokenAddresses,
         chainId,
         currency: nativeCurrency,
       });
 
-    return Object.entries(tokenPricesByTokenContractAddress).reduce(
-      (obj, [tokenContractAddress, tokenPrice]) => {
+    return Object.entries(tokenPricesByTokenAddress).reduce(
+      (obj, [tokenAddress, tokenPrice]) => {
         return {
           ...obj,
-          [tokenContractAddress]: tokenPrice.value,
+          [tokenAddress]: tokenPrice.value,
         };
       },
       {},
@@ -503,25 +503,25 @@ export class TokenRatesController extends PollingControllerV1<
    * API, then convert the prices to our desired native currency.
    *
    * @param args - The arguments to this function.
-   * @param args.tokenContractAddresses - The contract addresses for the tokens you
-   * want to retrieve prices for.
-   * @param args.nativeCurrency - The currency you want the prices to be in.
+   * @param args.tokenAddresses - Addresses for tokens.
+   * @param args.nativeCurrency - The native currency in which to request
+   * prices.
    * @returns A map of the token addresses (as checksums) to their prices in the
    * native currency.
    */
   async #fetchAndMapExchangeRatesForUnsupportedNativeCurrency({
-    tokenContractAddresses,
+    tokenAddresses,
     nativeCurrency,
   }: {
-    tokenContractAddresses: Hex[];
+    tokenAddresses: Hex[];
     nativeCurrency: string;
   }): Promise<ContractExchangeRates> {
     const [
-      tokenPricesByTokenContractAddress,
+      tokenPricesByTokenAddress,
       fallbackCurrencyToNativeCurrencyConversionRate,
     ] = await Promise.all([
       this.#tokenPricesService.fetchTokenPrices({
-        tokenContractAddresses,
+        tokenAddresses,
         currency: FALL_BACK_VS_CURRENCY,
         chainId: this.config.chainId,
       }),
@@ -535,11 +535,11 @@ export class TokenRatesController extends PollingControllerV1<
       return {};
     }
 
-    return Object.entries(tokenPricesByTokenContractAddress).reduce(
-      (obj, [tokenContractAddress, tokenPrice]) => {
+    return Object.entries(tokenPricesByTokenAddress).reduce(
+      (obj, [tokenAddress, tokenPrice]) => {
         return {
           ...obj,
-          [tokenContractAddress]:
+          [tokenAddress]:
             tokenPrice.value * fallbackCurrencyToNativeCurrencyConversionRate,
         };
       },
diff --git a/packages/assets-controllers/src/token-prices-service/abstract-token-prices-service.ts b/packages/assets-controllers/src/token-prices-service/abstract-token-prices-service.ts
@@ -3,23 +3,20 @@ import type { Hex } from '@metamask/utils';
 /**
  * Represents the price of a token in a currency.
  */
-export type TokenPrice<
-  TokenContractAddress extends Hex,
-  Currency extends string,
-> = {
-  tokenContractAddress: TokenContractAddress;
+export type TokenPrice<TokenAddress extends Hex, Currency extends string> = {
+  tokenAddress: TokenAddress;
   value: number;
   currency: Currency;
 };
 
 /**
- * A map of token contract address to its price.
+ * A map of token address to its price.
  */
-export type TokenPricesByTokenContractAddress<
-  TokenContractAddress extends Hex,
+export type TokenPricesByTokenAddress<
+  TokenAddress extends Hex,
   Currency extends string,
 > = {
-  [A in TokenContractAddress]: TokenPrice<A, Currency>;
+  [A in TokenAddress]: TokenPrice<A, Currency>;
 };
 
 /**
@@ -28,40 +25,37 @@ export type TokenPricesByTokenContractAddress<
  *
  * @template ChainId - A type union of valid arguments for the `chainId`
  * argument to `fetchTokenPrices`.
- * @template TokenContractAddress - A type union of all token contract
- * addresses. The reason this type parameter exists is so that we can guarantee
- * that same addresses that `fetchTokenPrices` receives are the same addresses
- * that shown up in the return value.
+ * @template TokenAddress - A type union of all token addresses. The reason this
+ * type parameter exists is so that we can guarantee that same addresses that
+ * `fetchTokenPrices` receives are the same addresses that shown up in the
+ * return value.
  * @template Currency - A type union of valid arguments for the `currency`
  * argument to `fetchTokenPrices`.
  */
 export type AbstractTokenPricesService<
   ChainId extends Hex = Hex,
-  TokenContractAddress extends Hex = Hex,
+  TokenAddress extends Hex = Hex,
   Currency extends string = string,
 > = {
   /**
    * Retrieves prices in the given currency for the tokens identified by the
-   * given contract addresses which are expected to live on the given chain.
+   * given addresses which are expected to live on the given chain.
    *
    * @param args - The arguments to this function.
    * @param args.chainId - An EIP-155 chain ID.
-   * @param args.tokenContractAddresses - Contract addresses for tokens that
-   * live on the chain.
+   * @param args.tokenAddresses - Addresses for tokens that live on the chain.
    * @param args.currency - The desired currency of the token prices.
    * @returns The prices for the requested tokens.
    */
   fetchTokenPrices({
     chainId,
-    tokenContractAddresses,
+    tokenAddresses,
     currency,
   }: {
     chainId: ChainId;
-    tokenContractAddresses: TokenContractAddress[];
+    tokenAddresses: TokenAddress[];
     currency: Currency;
-  }): Promise<
-    TokenPricesByTokenContractAddress<TokenContractAddress, Currency>
-  >;
+  }): Promise<TokenPricesByTokenAddress<TokenAddress, Currency>>;
 
   /**
    * Type guard for whether the API can return token prices for the given chain
diff --git a/packages/assets-controllers/src/token-prices-service/codefi-v2.test.ts b/packages/assets-controllers/src/token-prices-service/codefi-v2.test.ts
@@ -30,23 +30,23 @@ describe('codefiTokenPricesServiceV2', () => {
       const pricedTokensByAddress =
         await codefiTokenPricesServiceV2.fetchTokenPrices({
           chainId: '0x1',
-          tokenContractAddresses: ['0xAAA', '0xBBB', '0xCCC'],
+          tokenAddresses: ['0xAAA', '0xBBB', '0xCCC'],
           currency: 'ETH',
         });
 
       expect(pricedTokensByAddress).toStrictEqual({
         '0xAAA': {
-          tokenContractAddress: '0xAAA',
+          tokenAddress: '0xAAA',
           value: 148.17205755299946,
           currency: 'ETH',
         },
         '0xBBB': {
-          tokenContractAddress: '0xBBB',
+          tokenAddress: '0xBBB',
           value: 33689.98134554716,
           currency: 'ETH',
         },
         '0xCCC': {
-          tokenContractAddress: '0xCCC',
+          tokenAddress: '0xCCC',
           value: 148.1344197578456,
           currency: 'ETH',
         },
@@ -72,7 +72,7 @@ describe('codefiTokenPricesServiceV2', () => {
       await expect(
         codefiTokenPricesServiceV2.fetchTokenPrices({
           chainId: '0x1',
-          tokenContractAddresses: ['0xAAA', '0xBBB', '0xCCC'],
+          tokenAddresses: ['0xAAA', '0xBBB', '0xCCC'],
           currency: 'ETH',
         }),
       ).rejects.toThrow('Could not find price for "0xAAA" in "ETH"');
@@ -98,7 +98,7 @@ describe('codefiTokenPricesServiceV2', () => {
       await expect(
         codefiTokenPricesServiceV2.fetchTokenPrices({
           chainId: '0x1',
-          tokenContractAddresses: ['0xAAA', '0xBBB', '0xCCC'],
+          tokenAddresses: ['0xAAA', '0xBBB', '0xCCC'],
           currency: 'ETH',
         }),
       ).rejects.toThrow('Could not find price for "0xAAA" in "ETH"');
diff --git a/packages/assets-controllers/src/token-prices-service/codefi-v2.ts b/packages/assets-controllers/src/token-prices-service/codefi-v2.ts
