diff --git a/.env.template b/.env.template
index d031c30f1..e29dd57a9 100644
--- a/.env.template
+++ b/.env.template
@@ -5,3 +5,4 @@ TENDERLY_PROJECT=string
 TENDERLY_ACCESS_SECRET=string
 GELATO_API_KEY=string
 PUBLIC_NETWORK=number
+COINMARKETCAP_API_KEY=string # To get one, sign up for a free developer account with Coinmarketcap
diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml
index 3b372b22e..6edb56ee4 100644
--- a/.github/workflows/check.yml
+++ b/.github/workflows/check.yml
@@ -22,6 +22,7 @@ jobs:
           envkey_TENDERLY_PROJECT: ${{ secrets.TENDERLY_PROJECT }}
           envkey_TENDERLY_USER: ${{ secrets.TENDERLY_USER }}
           envkey_GELATO_API_KEY: ${{ secrets.GELATO_API_KEY }}
+          envkey_COINMARKETCAP_API_KEY: ${{ secrets.COINMARKETCAP_API_KEY }}
           envkey_PUBLIC_NETWORK: 5
 
       - name: Install dependencies
diff --git a/.github/workflows/e2e-tests.yml b/.github/workflows/e2e-tests.yml
index f93bc2013..296dab321 100644
--- a/.github/workflows/e2e-tests.yml
+++ b/.github/workflows/e2e-tests.yml
@@ -22,6 +22,7 @@ jobs:
           envkey_TENDERLY_PROJECT: ${{ secrets.TENDERLY_PROJECT }}
           envkey_TENDERLY_USER: ${{ secrets.TENDERLY_USER }}
           envkey_GELATO_API_KEY: ${{ secrets.GELATO_API_KEY }}
+          envkey_COINMARKETCAP_API_KEY: ${{ secrets.COINMARKETCAP_API_KEY }}
           envkey_PUBLIC_NETWORK: 5
 
       - name: Install dependencies
diff --git a/docs/DEVELOPMENT.md b/docs/DEVELOPMENT.md
index b9e31d42e..5711b2b9a 100644
--- a/docs/DEVELOPMENT.md
+++ b/docs/DEVELOPMENT.md
@@ -31,7 +31,7 @@ You can preview the production build with `npm run preview`.
 
 ## 🌳 Environment
 
-There are a few environment variables required for the app to function. You can find an overview under `.env.template`. Youʼll need access credentials for Pinata, Tenderly and a Gelato Relay API key for claiming projects. Youʼll also need to set up `PUBLIC_NETWORK`, as described right below.
+There are a few environment variables required for the app to function. You can find an overview under `.env.template`. Youʼll need access credentials for Pinata, Tenderly and a Gelato Relay API key for claiming projects. Youʼll also need to set up `PUBLIC_NETWORK`, as described right below. Lastly, you'll need to sign up for a free Coinmarketcap API developer account and populate the `COINMARKETCAP_API_KEY` var.
 
 ## 🔗 Chain Config
 
diff --git a/src/lib/components/aggregate-fiat-estimate/aggregate-fiat-estimate.svelte b/src/lib/components/aggregate-fiat-estimate/aggregate-fiat-estimate.svelte
index 4bc162ce9..dc0323a7f 100644
--- a/src/lib/components/aggregate-fiat-estimate/aggregate-fiat-estimate.svelte
+++ b/src/lib/components/aggregate-fiat-estimate/aggregate-fiat-estimate.svelte
@@ -1,5 +1,5 @@
 <script lang="ts">
-  import tokensStore, { type TokenInfoWrapper } from '$lib/stores/tokens/tokens.store';
+  import tokensStore from '$lib/stores/tokens/tokens.store';
   import fiatEstimates from '$lib/utils/fiat-estimates/fiat-estimates';
   import { fade } from 'svelte/transition';
   import WarningIcon from 'radicle-design-system/icons/ExclamationCircle.svelte';
@@ -15,22 +15,16 @@
 
   /** If undefined, component will display a loading state. */
   export let amounts: Amounts | undefined;
-  $: tokens =
-    (amounts &&
-      $tokensStore &&
-      amounts.map((amount) => tokensStore.getByAddress(amount.tokenAddress.toLowerCase()))) ??
-    [];
-  $: knownTokens = tokens.filter((token): token is TokenInfoWrapper => token !== undefined);
-  $: knownSymbols = knownTokens.map((token) => token.info.symbol);
+  $: tokenAddresses = amounts?.map((a) => a.tokenAddress);
 
   const fiatEstimatesStarted = fiatEstimates.started;
   $: {
-    if ($fiatEstimatesStarted) {
-      fiatEstimates.track(knownSymbols);
+    if ($fiatEstimatesStarted && tokenAddresses && tokenAddresses.length > 0) {
+      fiatEstimates.track(tokenAddresses);
     }
   }
 
-  $: priceStore = fiatEstimates.price(knownSymbols);
+  $: priceStore = fiatEstimates.price(tokenAddresses ?? []);
 
   let fiatEstimateCents: number | 'pending' = 'pending';
   let includesUnknownPrice = false;
@@ -38,7 +32,7 @@
   const connected = tokensStore.connected;
 
   $: {
-    if ($connected && amounts) {
+    if ($connected && amounts && $connected) {
       const prices = $priceStore;
 
       includesUnknownPrice = false;
@@ -47,7 +41,14 @@
         fiatEstimateCents = 'pending';
       } else {
         fiatEstimateCents = amounts.reduce((sum, { tokenAddress, amount }) => {
-          const res = fiatEstimates.convert({ amount, tokenAddress });
+          const token = tokensStore.getByAddress(tokenAddress);
+
+          if (!token) {
+            includesUnknownPrice = true;
+            return sum;
+          }
+
+          const res = fiatEstimates.convert({ amount, tokenAddress }, token.info.decimals);
 
           if (res === 'unsupported') {
             includesUnknownPrice = true;
diff --git a/src/lib/components/token-amounts-table/token-amounts-table.svelte b/src/lib/components/token-amounts-table/token-amounts-table.svelte
index 8c3886d3b..1bfe6f128 100644
--- a/src/lib/components/token-amounts-table/token-amounts-table.svelte
+++ b/src/lib/components/token-amounts-table/token-amounts-table.svelte
@@ -1,7 +1,7 @@
 <script lang="ts">
   import addCustomTokenFlowSteps from '$lib/flows/add-custom-token/add-custom-token-flow-steps';
   import modal from '$lib/stores/modal';
-  import tokensStore, { type TokenInfoWrapper } from '$lib/stores/tokens/tokens.store';
+  import tokensStore from '$lib/stores/tokens/tokens.store';
   import fiatEstimatesStore from '$lib/utils/fiat-estimates/fiat-estimates';
   import formatTokenAmount from '$lib/utils/format-token-amount';
   import unreachable from '$lib/utils/unreachable';
@@ -20,22 +20,40 @@
   }
 
   export let amounts: Amount[];
+  $: tokenAddresses = amounts.map((a) => a.tokenAddress);
+  $: tokens = tokenAddresses.map((a) => tokensStore.getByAddress(a));
 
-  $: tokens =
-    ($tokensStore && amounts.map((amount) => tokensStore.getByAddress(amount.tokenAddress))) ?? [];
-  $: knownTokens = tokens.filter((token): token is TokenInfoWrapper => token !== undefined);
-  $: knownSymbols = knownTokens.map((token) => token.info.symbol);
+  $: priceStore = fiatEstimatesStore.price(tokenAddresses ?? []);
 
-  $: priceStore = fiatEstimatesStore.price(knownSymbols);
+  const fiatEstimatesStarted = fiatEstimatesStore.started;
+  $: {
+    if ($fiatEstimatesStarted && tokenAddresses && tokenAddresses.length > 0) {
+      fiatEstimatesStore.track(tokenAddresses);
+    }
+  }
 
   let fiatEstimates: (number | 'pending' | 'unsupported' | undefined)[] = [];
 
+  const connected = tokensStore.connected;
+
   $: {
     $priceStore;
 
-    amounts.forEach(({ tokenAddress, amount }, index) => {
-      fiatEstimates[index] = fiatEstimatesStore.convert({ amount, tokenAddress });
-    });
+    if ($connected) {
+      amounts.forEach(({ tokenAddress, amount }, index) => {
+        const token = tokensStore.getByAddress(tokenAddress);
+
+        if (!token) {
+          fiatEstimates[index] = 'unsupported';
+          return;
+        }
+
+        fiatEstimates[index] = fiatEstimatesStore.convert(
+          { amount, tokenAddress },
+          token.info.decimals,
+        );
+      });
+    }
 
     fiatEstimates = fiatEstimates;
   }
diff --git a/src/lib/utils/fiat-estimates/binance-ws-api/supported-symbols.ts b/src/lib/utils/fiat-estimates/binance-ws-api/supported-symbols.ts
deleted file mode 100644
index 5c9fc60f5..000000000
--- a/src/lib/utils/fiat-estimates/binance-ws-api/supported-symbols.ts
+++ /dev/null
@@ -1,448 +0,0 @@
-// Fetched May 3rd, 2023
-export const SUPPORTED_SYMBOLS = [
-  'BTC',
-  'ETH',
-  'BNB',
-  'BCC',
-  'NEO',
-  'LTC',
-  'QTUM',
-  'ADA',
-  'XRP',
-  'EOS',
-  'TUSD',
-  'IOTA',
-  'XLM',
-  'ONT',
-  'TRX',
-  'ETC',
-  'ICX',
-  'VEN',
-  'NULS',
-  'VET',
-  'PAX',
-  'BCHABC',
-  'BCHSV',
-  'USDC',
-  'LINK',
-  'WAVES',
-  'BTT',
-  'USDS',
-  'ONG',
-  'HOT',
-  'ZIL',
-  'ZRX',
-  'FET',
-  'BAT',
-  'XMR',
-  'ZEC',
-  'IOST',
-  'CELR',
-  'DASH',
-  'NANO',
-  'OMG',
-  'THETA',
-  'ENJ',
-  'MITH',
-  'MATIC',
-  'ATOM',
-  'TFUEL',
-  'ONE',
-  'FTM',
-  'ALGO',
-  'USDSB',
-  'GTO',
-  'ERD',
-  'DOGE',
-  'DUSK',
-  'ANKR',
-  'WIN',
-  'COS',
-  'NPXS',
-  'COCOS',
-  'MTL',
-  'TOMO',
-  'PERL',
-  'DENT',
-  'MFT',
-  'KEY',
-  'STORM',
-  'DOCK',
-  'WAN',
-  'FUN',
-  'CVC',
-  'CHZ',
-  'BAND',
-  'BUSD',
-  'BEAM',
-  'XTZ',
-  'REN',
-  'RVN',
-  'HC',
-  'HBAR',
-  'NKN',
-  'STX',
-  'KAVA',
-  'ARPA',
-  'IOTX',
-  'RLC',
-  'MCO',
-  'CTXC',
-  'BCH',
-  'TROY',
-  'VITE',
-  'FTT',
-  'EUR',
-  'OGN',
-  'DREP',
-  'BULL',
-  'BEAR',
-  'ETHBULL',
-  'ETHBEAR',
-  'TCT',
-  'WRX',
-  'BTS',
-  'LSK',
-  'BNT',
-  'LTO',
-  'EOSBULL',
-  'EOSBEAR',
-  'XRPBULL',
-  'XRPBEAR',
-  'STRAT',
-  'AION',
-  'MBL',
-  'COTI',
-  'BNBBULL',
-  'BNBBEAR',
-  'STPT',
-  'WTC',
-  'DATA',
-  'XZC',
-  'SOL',
-  'CTSI',
-  'HIVE',
-  'CHR',
-  'BTCUP',
-  'BTCDOWN',
-  'GXS',
-  'ARDR',
-  'LEND',
-  'MDT',
-  'STMX',
-  'KNC',
-  'REP',
-  'LRC',
-  'PNT',
-  'COMP',
-  'BKRW',
-  'SC',
-  'ZEN',
-  'SNX',
-  'ETHUP',
-  'ETHDOWN',
-  'ADAUP',
-  'ADADOWN',
-  'LINKUP',
-  'LINKDOWN',
-  'VTHO',
-  'DGB',
-  'GBP',
-  'SXP',
-  'MKR',
-  'DAI',
-  'DCR',
-  'STORJ',
-  'BNBUP',
-  'BNBDOWN',
-  'XTZUP',
-  'XTZDOWN',
-  'MANA',
-  'AUD',
-  'YFI',
-  'BAL',
-  'BLZ',
-  'IRIS',
-  'KMD',
-  'JST',
-  'SRM',
-  'ANT',
-  'CRV',
-  'SAND',
-  'OCEAN',
-  'NMR',
-  'DOT',
-  'LUNA',
-  'RSR',
-  'PAXG',
-  'WNXM',
-  'TRB',
-  'BZRX',
-  'SUSHI',
-  'YFII',
-  'KSM',
-  'EGLD',
-  'DIA',
-  'RUNE',
-  'FIO',
-  'UMA',
-  'EOSUP',
-  'EOSDOWN',
-  'TRXUP',
-  'TRXDOWN',
-  'XRPUP',
-  'XRPDOWN',
-  'DOTUP',
-  'DOTDOWN',
-  'BEL',
-  'WING',
-  'LTCUP',
-  'LTCDOWN',
-  'UNI',
-  'NBS',
-  'OXT',
-  'SUN',
-  'AVAX',
-  'HNT',
-  'FLM',
-  'UNIUP',
-  'UNIDOWN',
-  'ORN',
-  'UTK',
-  'XVS',
-  'ALPHA',
-  'AAVE',
-  'NEAR',
-  'SXPUP',
-  'SXPDOWN',
-  'FIL',
-  'FILUP',
-  'FILDOWN',
-  'YFIUP',
-  'YFIDOWN',
-  'INJ',
-  'AUDIO',
-  'CTK',
-  'BCHUP',
-  'BCHDOWN',
-  'AKRO',
-  'AXS',
-  'HARD',
-  'DNT',
-  'STRAX',
-  'UNFI',
-  'ROSE',
-  'AVA',
-  'XEM',
-  'AAVEUP',
-  'AAVEDOWN',
-  'SKL',
-  'SUSD',
-  'SUSHIUP',
-  'SUSHIDOWN',
-  'XLMUP',
-  'XLMDOWN',
-  'GRT',
-  'JUV',
-  'PSG',
-  '1INCH',
-  'REEF',
-  'OG',
-  'ATM',
-  'ASR',
-  'CELO',
-  'RIF',
-  'BTCST',
-  'TRU',
-  'CKB',
-  'TWT',
-  'FIRO',
-  'LIT',
-  'SFP',
-  'DODO',
-  'CAKE',
-  'ACM',
-  'BADGER',
-  'FIS',
-  'OM',
-  'POND',
-  'DEGO',
-  'ALICE',
-  'LINA',
-  'PERP',
-  'RAMP',
-  'SUPER',
-  'CFX',
-  'EPS',
-  'AUTO',
-  'TKO',
-  'PUNDIX',
-  'TLM',
-  '1INCHUP',
-  '1INCHDOWN',
-  'BTG',
-  'MIR',
-  'BAR',
-  'FORTH',
-  'BAKE',
-  'BURGER',
-  'SLP',
-  'SHIB',
-  'ICP',
-  'AR',
-  'POLS',
-  'MDX',
-  'MASK',
-  'LPT',
-  'NU',
-  'XVG',
-  'ATA',
-  'GTC',
-  'TORN',
-  'KEEP',
-  'ERN',
-  'KLAY',
-  'PHA',
-  'BOND',
-  'MLN',
-  'DEXE',
-  'C98',
-  'CLV',
-  'QNT',
-  'FLOW',
-  'TVK',
-  'MINA',
-  'RAY',
-  'FARM',
-  'ALPACA',
-  'QUICK',
-  'MBOX',
-  'FOR',
-  'REQ',
-  'GHST',
-  'WAXP',
-  'TRIBE',
-  'GNO',
-  'XEC',
-  'ELF',
-  'DYDX',
-  'POLY',
-  'IDEX',
-  'VIDT',
-  'USDP',
-  'GALA',
-  'ILV',
-  'YGG',
-  'SYS',
-  'DF',
-  'FIDA',
-  'FRONT',
-  'CVP',
-  'AGLD',
-  'RAD',
-  'BETA',
-  'RARE',
-  'LAZIO',
-  'CHESS',
-  'ADX',
-  'AUCTION',
-  'DAR',
-  'BNX',
-  'RGT',
-  'MOVR',
-  'CITY',
-  'ENS',
-  'KP3R',
-  'QI',
-  'PORTO',
-  'POWR',
-  'VGX',
-  'JASMY',
-  'AMP',
-  'PLA',
-  'PYR',
-  'RNDR',
-  'ALCX',
-  'SANTOS',
-  'MC',
-  'ANY',
-  'BICO',
-  'FLUX',
-  'FXS',
-  'VOXEL',
-  'HIGH',
-  'CVX',
-  'PEOPLE',
-  'OOKI',
-  'SPELL',
-  'UST',
-  'JOE',
-  'ACH',
-  'IMX',
-  'GLMR',
-  'LOKA',
-  'SCRT',
-  'API3',
-  'BTTC',
-  'ACA',
-  'ANC',
-  'XNO',
-  'WOO',
-  'ALPINE',
-  'T',
-  'ASTR',
-  'NBT',
-  'GMT',
-  'KDA',
-  'APE',
-  'BSW',
-  'BIFI',
-  'MULTI',
-  'STEEM',
-  'MOB',
-  'NEXO',
-  'REI',
-  'GAL',
-  'LDO',
-  'EPX',
-  'OP',
-  'LEVER',
-  'STG',
-  'LUNC',
-  'GMX',
-  'NEBL',
-  'POLYX',
-  'APT',
-  'OSMO',
-  'HFT',
-  'PHB',
-  'HOOK',
-  'MAGIC',
-  'HIFI',
-  'RPL',
-  'PROS',
-  'AGIX',
-  'GNS',
-  'SYN',
-  'VIB',
-  'SSV',
-  'LQTY',
-  'AMB',
-  'BETH',
-  'USTC',
-  'GAS',
-  'GLM',
-  'PROM',
-  'QKC',
-  'UFT',
-  'ID',
-  'ARB',
-  'LOOM',
-  'OAX',
-  'RDNT',
-  'WBTC',
-  'EDU',
-  'SUI',
-] as const;
-
-export type SupportedSymbol = (typeof SUPPORTED_SYMBOLS)[number];
diff --git a/src/lib/utils/fiat-estimates/binance-ws-api/types.ts b/src/lib/utils/fiat-estimates/binance-ws-api/types.ts
deleted file mode 100644
index 9adb0357f..000000000
--- a/src/lib/utils/fiat-estimates/binance-ws-api/types.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import z from 'zod';
-
-export const Binance24hTickerMessage = z.object({
-  e: z.literal('24hrTicker'), // Event type
-  E: z.number(), // Event time
-  s: z.string(), // Symbol
-  p: z.string(), // Price change
-  P: z.string(), // Price change percent
-  w: z.string(), // Weighted average price
-  x: z.string(), // First trade(F)-1 price (first trade before the 24hr rolling window)
-  c: z.string(), // Last price
-  Q: z.string(), // Last quantity
-  b: z.string(), // Best bid price
-  B: z.string(), // Best bid quantity
-  a: z.string(), // Best ask price
-  A: z.string(), // Best ask quantity
-  o: z.string(), // Open price
-  h: z.string(), // High price
-  l: z.string(), // Low price
-  v: z.string(), // Total traded base asset volume
-  q: z.string(), // Total traded quote asset volume
-  O: z.number(), // Statistics open time
-  C: z.number(), // Statistics close time
-  F: z.number(), // First trade ID
-  L: z.number(), // Last trade Id
-  n: z.number(), // Total number of trades
-});
-
-export const BinanceCommandResponse = z.object({
-  result: z.nullable(z.string()),
-  id: z.number(),
-});
-
-export const BinanceMessage = z.union([Binance24hTickerMessage, BinanceCommandResponse]);
-
-export const BinanceSubscribeCommand = z.object({
-  method: z.literal('SUBSCRIBE'),
-  params: z.array(z.string()),
-  id: z.number(),
-});
-
-export const BinanceUnsubscribeCommand = z.object({
-  method: z.literal('UNSUBSCRIBE'),
-  params: z.array(z.string()),
-  id: z.number(),
-});
-
-export const BinanceCommand = z.union([BinanceSubscribeCommand, BinanceUnsubscribeCommand]);
diff --git a/src/lib/utils/fiat-estimates/fiat-estimates.ts b/src/lib/utils/fiat-estimates/fiat-estimates.ts
index 84f740606..2d0ef77bd 100644
--- a/src/lib/utils/fiat-estimates/fiat-estimates.ts
+++ b/src/lib/utils/fiat-estimates/fiat-estimates.ts
@@ -1,237 +1,168 @@
 import { derived, writable, get } from 'svelte/store';
 import assert from '$lib/utils/assert';
 import deduplicateReadable from '../deduplicate-readable';
-import tokensStore from '$lib/stores/tokens/tokens.store';
-import createSocket from './sockets';
-import { BinanceCommand, BinanceMessage } from './binance-ws-api/types';
-import { SUPPORTED_SYMBOLS, type SupportedSymbol } from './binance-ws-api/supported-symbols';
-import type { z } from 'zod';
+import { z } from 'zod';
 import { formatUnits } from 'ethers/lib/utils';
+import { utils } from 'ethers';
+
+type TokenAddress = string;
+type DataProviderTokenId = number;
 
 interface Amount {
   amount: bigint;
-  tokenAddress: string;
+  tokenAddress: TokenAddress;
 }
 
-/** Price value is this if Binance doesnʼt provide a price for the given asset. */
+/** Price value is this if the data provider doesnʼt provide a price for the given asset. */
 type Unsupported = 'unsupported';
 
-/** Price value is this if we're waiting for Binance to provide a price for the first time. */
+/** Price value is this if we're waiting for the data provider to post a price for the first time. */
 type Pending = 'pending';
 
-/** All prices relative to USDT */
+/** All prices relative to USD */
 type Prices = {
-  [symbol: string]: number | Unsupported | Pending;
-};
-
-/** Some ERC-20s not directly traded on Binance are pegged to the value of another currency. */
-const TOKEN_SUBSTITUTIONS: { [symbol: string]: SupportedSymbol } = {
-  WETH: 'ETH',
-  WEENUS: 'ETH',
-  WBTC: 'BTC',
+  [tokenAddress: TokenAddress]: number | Unsupported | Pending;
 };
 
 const prices = writable<Prices>({});
 
-function _handleMessage(e: MessageEvent<z.infer<typeof BinanceMessage>>) {
-  const { data } = e;
+let idMap: { [tokenAddress: TokenAddress]: DataProviderTokenId } | undefined = undefined;
 
-  if ('e' in data && data.e === '24hrTicker') {
-    const symbol = data.s.replace('USDT', '');
-    const price = parseFloat(data.c);
+const started = writable(false);
 
-    prices.update((prices) => ({
-      ...prices,
-      [symbol]: price,
-    }));
-  }
-}
+/** Establish a connection to the data provider. */
+export async function start() {
+  const idMapRes = await (await fetch('/api/fiat-estimates/id-map')).json();
 
-function _validateSymbol(symbol: string): asserts symbol is SupportedSymbol {
-  assert(SUPPORTED_SYMBOLS.includes(symbol as SupportedSymbol), `Unsupported symbol: ${symbol}`);
-}
+  idMap = z.record(z.string(), z.number()).parse(idMapRes);
 
-let connection:
-  | ReturnType<typeof createSocket<typeof BinanceMessage, typeof BinanceCommand>>
-  | undefined;
-const started = writable(false);
-const socketOpen = writable(false);
-
-/** Establish a websocket connection and allow tracking prices. */
-export function start() {
-  return new Promise<void>((resolve) => {
-    connection = createSocket(
-      BinanceMessage,
-      BinanceCommand,
-      'wss://stream.binance.com:9443/ws/radusdt@ticker',
-    );
-
-    started.set(true);
-
-    const { send, subscribe } = connection;
-
-    /*
-    Establishing a socket connection requires subscribing to some random symbol,
-    but we immediately unsubscribe on open and resolve the start promise.
-    */
-    connection.socket.addEventListener(
-      'open',
-      () => {
-        send({
-          method: 'UNSUBSCRIBE',
-          params: ['radusdt@ticker'],
-          id: 1,
-        });
-
-        socketOpen.set(true);
-
-        resolve();
-      },
-      { once: true },
-    );
-
-    subscribe(_handleMessage);
-  });
-}
+  started.set(true);
 
-/** Destroy any previously-started websocket connection. */
-export function stop() {
-  connection?.destroy();
-  socketOpen.set(false);
-  started.set(false);
-  connection = undefined;
+  return;
 }
 
-/** Start tracking the provided symbols. */
-export async function track(symbols: string[]) {
-  assert(connection, 'Socket not initialized');
-
-  // If socketOpen is false, wait for it to open
-  if (!get(socketOpen)) {
-    await new Promise<void>((resolve) => {
-      const unsubscribe = socketOpen.subscribe((open) => {
-        if (open) {
-          unsubscribe();
-          resolve();
-        }
-      });
-    });
-  }
+/** Start tracking the provided addresses. */
+export async function track(addresses: TokenAddress[]) {
+  assert(
+    idMap,
+    'Store not started, ensure `start` is called and wait for `started` to be true first.',
+  );
 
-  const pv = get(prices);
+  const pricesValue = get(prices);
+
+  // Validate all the addresses are valid ETH addresses
+  addresses.forEach((address) => {
+    assert(utils.isAddress(address), `Invalid address: ${address}`);
+  });
 
-  symbols = symbols
-    .map((symbol) => TOKEN_SUBSTITUTIONS[symbol] || symbol)
-    .filter((symbol) => !pv[symbol]);
+  // If we're already tracking any of the given addresses, remove them from the list.
+  addresses = addresses.filter(
+    (address) => !Object.keys(pricesValue).includes(utils.getAddress(address)),
+  );
 
-  // Set values for all unsupported symbols in prices store to unsupported.
-  prices.update((prices) => {
-    const newPrices: Prices = {};
+  // Make all the addresses lowercase
+  addresses = addresses.map((address) => address.toLowerCase());
 
-    for (const symbol of symbols) {
-      if (!SUPPORTED_SYMBOLS.includes(symbol as SupportedSymbol)) {
-        newPrices[symbol] = 'unsupported';
-      }
-    }
+  // If the list is empty, we're done.
+  if (addresses.length === 0) return;
 
-    return {
-      ...prices,
-      ...newPrices,
-    };
+  // Update all the tracked addresses to have a price of `pending`.
+  addresses.forEach((address) => {
+    prices.set({
+      ...pricesValue,
+      [utils.getAddress(address)]: 'pending',
+    });
   });
 
-  // Filter out all unsupported symbols.
-  symbols = symbols.filter((symbol) => SUPPORTED_SYMBOLS.includes(symbol as SupportedSymbol));
+  // Ensure all addresses are known to the ID map and build a list of address <> ID pairs.
+  // If the address isn't known, assign it an ID of `undefined`.
+  const ids: [TokenAddress, DataProviderTokenId | undefined][] = [];
+  addresses.forEach((address) => {
+    assert(idMap);
 
-  // Set values for all the supported symbols in prices store to pending.
-  prices.update((prices) => {
-    const newPrices: Prices = {};
+    const id: number | undefined = idMap[address];
 
-    for (const symbol of symbols) {
-      newPrices[symbol] = 'pending';
-    }
+    ids.push([address, id]);
+  });
 
-    return {
-      ...prices,
-      ...newPrices,
-    };
+  // Set the price for all token addresses with unknown IDs to `unsupported`.
+  ids.forEach((i) => {
+    if (i[1] === undefined) {
+      prices.update(($prices) => ({
+        ...$prices,
+        [utils.getAddress(i[0])]: 'unsupported',
+      }));
+    }
   });
 
-  if (symbols.length === 0) return;
+  const knownIds: [TokenAddress, DataProviderTokenId][] = ids.filter(
+    (i): i is [string, number] => i[1] !== undefined,
+  );
 
-  connection.send({
-    method: 'SUBSCRIBE',
-    params: symbols.map((symbol) => `${symbol.toLowerCase()}usdt@ticker`),
-    id: 1,
-  });
-}
+  // Build a string of all known IDs
+  const idString = knownIds.map((i) => i[1]).join(',');
 
-/** Stop tracking the provided symbols. */
-export async function untrack(symbols: string[]) {
-  assert(connection, 'Socket not initialized');
+  // Request the current prices for all tracked assets from /api/fiat-estimates/price/tokenId1,tokenId2,...
+  const priceRes = await fetch(`/api/fiat-estimates/price/${idString}`);
 
-  symbols = symbols.map((symbol) => TOKEN_SUBSTITUTIONS[symbol] || symbol);
+  const parsedRes = z.record(z.string(), z.number()).parse(await priceRes.json());
 
-  connection.send({
-    method: 'UNSUBSCRIBE',
-    params: symbols.map((symbol) => `${symbol.toLowerCase()}usdt@ticker`),
-    id: 1,
+  // Update the prices store with the new prices
+  prices.update(($prices) => {
+    return {
+      ...$prices,
+      ...Object.fromEntries(
+        Object.values(knownIds).map(([address, id]) => [utils.getAddress(address), parsedRes[id]]),
+      ),
+    };
   });
 }
 
 /**
  * Convert the given amount to USD.
  * @param amount The amount to convert.
+ * @param tokenDecimals The amount of decimals for the token the amount is in.
  * @returns A float representing the amount in USD, `undefined` if the asset
- * isnʼt currently tracked, `pending` if we're waiting for Binance to report
- * the price for the first time, or `unsupported` if Binance doesnʼt provide
+ * isnʼt currently tracked, `pending` if we're waiting for the data provider to
+ * report the price for the first time, or `unsupported` if it can't provide
  * a price for the given asset.
  */
-export function convert(amount: Amount) {
-  const token = tokensStore.getByAddress(amount.tokenAddress);
-
-  if (!token) return 'unsupported';
-
-  let symbol = token.info.symbol;
-  symbol = TOKEN_SUBSTITUTIONS[symbol] || symbol;
+export function convert(amount: Amount, tokenDecimals: number) {
+  let { tokenAddress } = amount;
+  tokenAddress = utils.getAddress(tokenAddress);
 
-  try {
-    _validateSymbol(symbol);
-  } catch {
-    return 'unsupported';
-  }
-
-  const price = get(prices)[symbol];
+  const price = get(prices)[tokenAddress];
 
   if (!price) return undefined;
   if (typeof price === 'string') return price;
 
-  const tokenAmount = parseFloat(formatUnits(amount.amount, token.info.decimals));
+  const tokenAmount = parseFloat(formatUnits(amount.amount, tokenDecimals));
 
   return tokenAmount * price;
 }
 
 /**
  * Create a deduplicated readable that notifies whenever the price for any of the given
- * symbols changes.
- * @param symbols The symbols to subscribe to.
+ * tokenAddresses changes.
+ * @param tokenAddresses The tokens to subscribe to.
  */
-const price = (symbols: string[]) =>
-  deduplicateReadable(
-    derived(prices, ($prices) => {
-      symbols = symbols.map((symbol) => TOKEN_SUBSTITUTIONS[symbol] || symbol);
+const price = (tokenAddresses: TokenAddress[]) => {
+  tokenAddresses = tokenAddresses.map((address) => utils.getAddress(address));
 
+  return deduplicateReadable(
+    derived(prices, ($prices) => {
       // Return an object of all the prices for the given symbols.
-      return Object.fromEntries(symbols.map((symbol) => [symbol, $prices[symbol] || 'pending']));
+      return Object.fromEntries(
+        tokenAddresses.map((tokenAddress) => [tokenAddress, $prices[tokenAddress] || 'pending']),
+      );
     }),
   );
+};
 
 export default {
   start,
-  stop,
   started: { subscribe: started.subscribe },
   track,
-  untrack,
   price,
   convert,
 };
diff --git a/src/lib/utils/fiat-estimates/sockets.ts b/src/lib/utils/fiat-estimates/sockets.ts
deleted file mode 100644
index ba230b584..000000000
--- a/src/lib/utils/fiat-estimates/sockets.ts
+++ /dev/null
@@ -1,58 +0,0 @@
-import type { ZodType, z } from 'zod';
-
-function _destroy(socket: WebSocket) {
-  socket.close();
-}
-
-function _handleMessage<MessageType extends ZodType>(
-  schema: MessageType,
-  e: MessageEvent<z.infer<MessageType>>,
-  callback: (e: MessageEvent<z.infer<MessageType>>) => void,
-) {
-  const data = schema.parse(JSON.parse(e.data));
-  callback({ ...e, data });
-}
-
-function _subscribe(
-  socket: WebSocket,
-  messageSchema: ZodType,
-  callback: (e: MessageEvent) => void,
-) {
-  socket.addEventListener('message', (e) => _handleMessage(messageSchema, e, callback));
-}
-
-function _unsubscribe(socket: WebSocket, callback: (e: MessageEvent) => void) {
-  socket.removeEventListener('message', callback);
-}
-
-function _send<MessageType extends ZodType>(
-  socket: WebSocket,
-  schema: MessageType,
-  message: z.infer<MessageType>,
-) {
-  socket.send(JSON.stringify(schema.parse(message)));
-}
-
-export default function createSocket<MessageType extends ZodType, CommandType extends ZodType>(
-  messageSchema: MessageType,
-  commandSchema: CommandType,
-  ...args: ConstructorParameters<typeof WebSocket>
-): {
-  socket: WebSocket;
-  subscribe: (callback: (e: MessageEvent<z.infer<typeof messageSchema>>) => void) => void;
-  unsubscribe: (callback: (e: MessageEvent<z.infer<typeof messageSchema>>) => void) => void;
-  send: (message: z.infer<typeof commandSchema>) => void;
-  destroy: () => void;
-} {
-  const socket = new WebSocket(...args);
-
-  return {
-    socket,
-    subscribe: (callback: (e: MessageEvent<z.infer<MessageType>>) => void) =>
-      _subscribe(socket, messageSchema, callback),
-    unsubscribe: (callback: (e: MessageEvent<z.infer<CommandType>>) => void) =>
-      _unsubscribe(socket, callback),
-    send: (message: z.infer<CommandType>) => _send(socket, commandSchema, message),
-    destroy: () => _destroy(socket),
-  };
-}
diff --git a/src/lib/utils/fiat-estimates/track-relevant-tokens.ts b/src/lib/utils/fiat-estimates/track-relevant-tokens.ts
deleted file mode 100644
index 6693450bc..000000000
--- a/src/lib/utils/fiat-estimates/track-relevant-tokens.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-import balancesStore from '$lib/stores/balances/balances.store';
-import tokensStore from '$lib/stores/tokens/tokens.store';
-import { derived } from 'svelte/store';
-import mapFilterUndefined from '../map-filter-undefined';
-import deduplicateReadable from '../deduplicate-readable';
-import fiatEstimates from './fiat-estimates';
-
-const allRelevantTokens = deduplicateReadable(
-  derived([balancesStore], ([$balancesStore]) => {
-    const allTokenAddresses = Object.values($balancesStore.accounts).reduce<string[]>(
-      (acc, account) => [...acc, ...Object.keys(account.tokens)],
-      [],
-    );
-
-    const symbols = mapFilterUndefined(
-      allTokenAddresses,
-      (tokenAddress) => tokensStore.getByAddress(tokenAddress)?.info.symbol,
-    );
-
-    return symbols;
-  }),
-);
-
-let unsubscriber: (() => void) | undefined;
-let previousTokens: string[] = [];
-
-/**
- * Begin automatically tracking and untracking tokens as they are added and removed from the accounts
- * currently stored in memory.
- */
-function start() {
-  unsubscriber = allRelevantTokens.subscribe((v) => {
-    const tokensToTrack = v.filter((token) => !previousTokens.includes(token));
-    const tokensToUntrack = previousTokens.filter((token) => !v.includes(token));
-
-    if (tokensToTrack.length > 0) fiatEstimates.track(tokensToTrack);
-    if (tokensToUntrack.length > 0) fiatEstimates.untrack(tokensToUntrack);
-
-    previousTokens = v;
-  });
-}
-
-function stop() {
-  unsubscriber?.();
-  unsubscriber = undefined;
-
-  fiatEstimates.untrack(previousTokens);
-
-  previousTokens = [];
-}
-
-export default {
-  start,
-  stop,
-};
diff --git a/src/routes/api/fiat-estimates/id-map/+server.ts b/src/routes/api/fiat-estimates/id-map/+server.ts
new file mode 100644
index 000000000..46b6c19ed
--- /dev/null
+++ b/src/routes/api/fiat-estimates/id-map/+server.ts
@@ -0,0 +1,58 @@
+import { COINMARKETCAP_API_KEY } from '$env/static/private';
+import { z } from 'zod';
+import mapFilterUndefined from '$lib/utils/map-filter-undefined';
+import type { RequestHandler } from './$types';
+
+const cmcResponseSchema = z.object({
+  data: z.array(
+    z.object({
+      id: z.number(),
+      symbol: z.string(),
+      name: z.string(),
+      platform: z
+        .object({
+          id: z.number(),
+          token_address: z.string().nullable(),
+          slug: z.string().nullable(),
+        })
+        .nullable(),
+    }),
+  ),
+});
+
+const COINMARKETCAP_ETHEREUM_PLATFORM_ID = 1;
+
+// TODO: Find some way to not fetch and send back the entire list of all tokens on CoinMarketCap,
+// but only the ones currently needed for estimates.
+
+export const GET: RequestHandler = async () => {
+  const idMapRes = await fetch(
+    `https://pro-api.coinmarketcap.com/v1/cryptocurrency/map?CMC_PRO_API_KEY=${COINMARKETCAP_API_KEY}`,
+  );
+
+  const parsed = cmcResponseSchema.parse(await idMapRes.json());
+
+  const idMap = Object.fromEntries(
+    mapFilterUndefined(parsed.data, (tokenData) => {
+      // Don't include if platform is not Ethereum
+      if (
+        !tokenData.platform ||
+        tokenData.platform.id !== COINMARKETCAP_ETHEREUM_PLATFORM_ID ||
+        !tokenData.platform?.token_address
+      ) {
+        return undefined;
+      }
+
+      return [tokenData.platform.token_address.replaceAll(' ', '').toLowerCase(), tokenData.id];
+    }),
+  );
+
+  // Manually add in the RAD token since it's missing a platform value on CMC for some reason
+  idMap['0x31c8eacbffdd875c74b94b077895bd78cf1e64a3'] = 6843;
+
+  return new Response(JSON.stringify(idMap), {
+    headers: {
+      'content-type': 'application/json',
+    },
+  });
+};
diff --git a/src/routes/api/fiat-estimates/price/[token_ids]/+server.ts b/src/routes/api/fiat-estimates/price/[token_ids]/+server.ts
new file mode 100644
index 000000000..675e3f8b0
--- /dev/null
+++ b/src/routes/api/fiat-estimates/price/[token_ids]/+server.ts
@@ -0,0 +1,51 @@
+import type { RequestHandler } from './$types';
+import { error } from '@sveltejs/kit';
+import { COINMARKETCAP_API_KEY } from '$env/static/private';
+import { z } from 'zod';
+
+const cmcResponseSchema = z.object({
+  data: z.record(
+    z.string(),
+    z.object({
+      quote: z.object({
+        USD: z.object({
+          price: z.number(),
+        }),
+      }),
+    }),
+  ),
+});
+
+export const GET: RequestHandler = async ({ params }) => {
+  const { token_ids } = params;
+
+  // tokenIds is a comma-separated string of IDs, so parse it as such
+  const tokenIds = token_ids.split(',');
+
+  // Ensure all the token IDs are numeric strings
+  try {
+    z.array(z.preprocess(Number, z.number())).parse(tokenIds);
+  } catch {
+    throw error(400, 'Invalid token ID submitted');
+  }
+
+  const priceRes = await fetch(
+    `https://pro-api.coinmarketcap.com/v2/cryptocurrency/quotes/latest?CMC_PRO_API_KEY=${COINMARKETCAP_API_KEY}&id=${token_ids}&convert=usd`,
+  );
+
+  const parsedRes = cmcResponseSchema.parse(await priceRes.json());
+
+  // Return an object of tokenAddresses with their prices
+  return new Response(
+    JSON.stringify(
+      Object.fromEntries(
+        tokenIds.map((tokenId) => [tokenId, parsedRes.data[tokenId].quote.USD.price]),
+      ),
+    ),
+    {
+      headers: {
+        'content-type': 'application/json',
+      },
+    },
+  );
+};
diff --git a/src/routes/app/+layout.svelte b/src/routes/app/+layout.svelte
index 50e96cde6..7829d2bee 100644
--- a/src/routes/app/+layout.svelte
+++ b/src/routes/app/+layout.svelte
@@ -20,7 +20,6 @@
   import cupertinoPaneStore from '$lib/stores/cupertino-pane/cupertino-pane.store';
   import breakpointsStore from '$lib/stores/breakpoints/breakpoints.store';
   import fiatEstimates from '$lib/utils/fiat-estimates/fiat-estimates';
-  import trackRelevantTokens from '$lib/utils/fiat-estimates/track-relevant-tokens';
   import ModalLayout from '$lib/components/modal-layout/modal-layout.svelte';
   import Spinner from '$lib/components/spinner/spinner.svelte';
   import { page } from '$app/stores';
@@ -144,12 +143,6 @@
 
   onMount(async () => {
     await fiatEstimates.start();
-    trackRelevantTokens.start();
-
-    return () => {
-      trackRelevantTokens.stop();
-      fiatEstimates.stop();
-    };
   });
 </script>