diff --git a/package-lock.json b/package-lock.json
index 9ea2d4cdc..bbdf5a7a9 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -44,6 +44,7 @@
         "recharts": "^2.15.3",
         "ripple-address-codec": "^5.0.0",
         "ripple-binary-codec": "^2.9.0",
+        "tldts": "^6.1.86",
         "topojson-client": "^3.0.0",
         "usehooks-ts": "^3.1.0",
         "vite": "^7.3.2",
diff --git a/package.json b/package.json
index cc8d56238..5e4abf037 100644
--- a/package.json
+++ b/package.json
@@ -42,6 +42,7 @@
     "recharts": "^2.15.3",
     "ripple-address-codec": "^5.0.0",
     "ripple-binary-codec": "^2.9.0",
+    "tldts": "^6.1.86",
     "topojson-client": "^3.0.0",
     "usehooks-ts": "^3.1.0",
     "vite": "^7.3.2",
diff --git a/src/containers/Accounts/AccountAsset/assetTables/NFTTable.tsx b/src/containers/Accounts/AccountAsset/assetTables/NFTTable.tsx
index f3b3b37b7..1f19cd93e 100644
--- a/src/containers/Accounts/AccountAsset/assetTables/NFTTable.tsx
+++ b/src/containers/Accounts/AccountAsset/assetTables/NFTTable.tsx
@@ -16,9 +16,9 @@ import { XRP_BASE } from '../../../shared/transactionUtils'
 import {
   localizeNumber,
   shortenAccount,
-  shortenDomain,
   shortenNFTTokenID,
 } from '../../../shared/utils'
+import { shortenDomain } from '../../../shared/domainUtils'
 import { XRP_SMALL_BALANCE_CURRENCY_OPTIONS } from '../../../shared/NumberFormattingUtils'
 import { useLanguage } from '../../../shared/hooks'
 import logger from '../../../../rippled/lib/logger'
diff --git a/src/containers/Token/IOU/Header/index.tsx b/src/containers/Token/IOU/Header/index.tsx
index b826b5091..03003e323 100644
--- a/src/containers/Token/IOU/Header/index.tsx
+++ b/src/containers/Token/IOU/Header/index.tsx
@@ -18,7 +18,11 @@ import {
   parsePercent,
   parsePrice,
 } from '../../../shared/NumberFormattingUtils'
-import { shortenDomain, stripHttpProtocol } from '../../../shared/utils'
+import {
+  getRegistrableDomain,
+  shortenDomainFromLeft,
+} from '../../../shared/domainUtils'
+import { calculateIouCirculatingSupply } from '../../shared/utils/circulatingSupply'
 
 interface HeaderProps {
   currency: string
@@ -30,27 +34,6 @@ interface HeaderProps {
   isAmmTvlLoading: boolean
 }
 
-const calculateCirculatingSupply = (
-  tokenData: LOSToken,
-  holdersData: TokenHoldersData | undefined,
-): number => {
-  if (tokenData.circ_supply) {
-    return Number(tokenData.circ_supply)
-  }
-  let circSupply = Number(tokenData.supply) || holdersData?.totalSupply || 0
-
-  // For stablecoins, don't subtract large percentage holders from circulating supply
-  if (tokenData.asset_subclass !== 'stablecoin' && holdersData) {
-    holdersData.holders.forEach((holder) => {
-      if (holder.percent >= 20) {
-        circSupply -= holder.balance
-      }
-    })
-  }
-
-  return circSupply
-}
-
 export const Header = ({
   currency,
   tokenData,
@@ -61,7 +44,7 @@ export const Header = ({
   isAmmTvlLoading,
 }: HeaderProps) => {
   const { t } = useTranslation()
-  const circSupply = calculateCirculatingSupply(tokenData, holdersData)
+  const circSupply = calculateIouCirculatingSupply(tokenData, holdersData)
   const xrpRate = Number(xrpUSDRate) || 0
 
   // Memoized formatted overview data
@@ -178,11 +161,10 @@ export const Header = ({
               <DomainLink
                 className="domain-link"
                 domain={tokenData.issuer_domain}
-                displayDomain={shortenDomain(
-                  stripHttpProtocol(tokenData.issuer_domain),
-                  12,
-                  7,
+                displayDomain={shortenDomainFromLeft(
+                  getRegistrableDomain(tokenData.issuer_domain),
                 )}
+                title={tokenData.issuer_domain}
               />
             </div>
           </div>
diff --git a/src/containers/Token/IOU/hooks/useMarketCalculations.ts b/src/containers/Token/IOU/hooks/useMarketCalculations.ts
deleted file mode 100644
index 4323830ca..000000000
--- a/src/containers/Token/IOU/hooks/useMarketCalculations.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import { useMemo } from 'react'
-import { formatPrice } from '../../../shared/utils'
-import { TokenHoldersData } from '../api/holders'
-import { LOSToken } from '../../../shared/losTypes'
-import {
-  calculateCirculatingSupply,
-  formatCirculatingSupply,
-} from '../utils/tokenCalculations'
-
-interface MarketCalculations {
-  marketCap: string | null
-  circSupply: number
-  formattedCircSupply: string
-}
-
-interface UseMarketCalculationsProps {
-  holdersData: TokenHoldersData | undefined
-  tokenData: LOSToken
-  price: string
-  xrpUSDRate: string
-  isHoldersDataLoading: boolean
-}
-
-export const useMarketCalculations = ({
-  holdersData,
-  tokenData,
-  price,
-  xrpUSDRate,
-  isHoldersDataLoading,
-}: UseMarketCalculationsProps): MarketCalculations =>
-  useMemo(() => {
-    const circSupply = calculateCirculatingSupply(holdersData, tokenData)
-
-    const marketCap =
-      !isHoldersDataLoading && circSupply && price && xrpUSDRate
-        ? formatPrice(
-            Number(circSupply) * Number(price) * Number(xrpUSDRate),
-          ) || null
-        : null
-
-    const formattedCircSupply = formatCirculatingSupply(circSupply)
-
-    return {
-      marketCap,
-      circSupply,
-      formattedCircSupply,
-    }
-  }, [holdersData, tokenData, price, xrpUSDRate, isHoldersDataLoading])
diff --git a/src/containers/Token/IOU/test/Header/Header.test.tsx b/src/containers/Token/IOU/test/Header/Header.test.tsx
index 5f048d197..877a1284d 100644
--- a/src/containers/Token/IOU/test/Header/Header.test.tsx
+++ b/src/containers/Token/IOU/test/Header/Header.test.tsx
@@ -31,8 +31,6 @@ jest.mock('../../../../shared/utils', () => ({
     return { num: d.toString(), unit: '' }
   },
   formatSmallNumber: (value: number) => value.toFixed(4),
-  shortenDomain: (domain: string) => domain,
-  stripHttpProtocol: (url: string) => url.replace(/^https?:\/\//, ''),
 }))
 
 const TestWrapper = ({ children }: { children: React.ReactNode }) => (
diff --git a/src/containers/Token/IOU/test/hooks/useMarketCalculations.test.ts b/src/containers/Token/IOU/test/hooks/useMarketCalculations.test.ts
deleted file mode 100644
index 040ffdf52..000000000
--- a/src/containers/Token/IOU/test/hooks/useMarketCalculations.test.ts
+++ /dev/null
@@ -1,273 +0,0 @@
-import { renderHook } from '@testing-library/react'
-import { useMarketCalculations } from '../../hooks/useMarketCalculations'
-import { TokenHoldersData } from '../../api/holders'
-import { LOSToken } from '../../../../shared/losTypes'
-
-describe('useMarketCalculations', () => {
-  const mockTokenData: LOSToken = {
-    currency: 'USD',
-    issuer_account: 'rIssuer',
-    trustlines: 100,
-    index: 0,
-  }
-
-  const mockHoldersData: TokenHoldersData = {
-    totalSupply: 1000000,
-    totalHolders: 100,
-    holders: [],
-  }
-
-  it('returns market calculations with valid data', () => {
-    const { result } = renderHook(() =>
-      useMarketCalculations({
-        holdersData: mockHoldersData,
-        tokenData: { ...mockTokenData, supply: '1000000' },
-        price: '0.5',
-        xrpUSDRate: '2',
-        isHoldersDataLoading: false,
-      }),
-    )
-
-    expect(result.current.circSupply).toBe(1000000)
-    expect(result.current.formattedCircSupply).toBeDefined()
-    expect(result.current.marketCap).toBeDefined()
-  })
-
-  it('returns null marketCap when isHoldersDataLoading is true', () => {
-    const { result } = renderHook(() =>
-      useMarketCalculations({
-        holdersData: mockHoldersData,
-        tokenData: { ...mockTokenData, supply: '1000000' },
-        price: '0.5',
-        xrpUSDRate: '2',
-        isHoldersDataLoading: true,
-      }),
-    )
-
-    expect(result.current.marketCap).toBeNull()
-  })
-
-  it('returns null marketCap when circSupply is 0', () => {
-    const { result } = renderHook(() =>
-      useMarketCalculations({
-        holdersData: undefined,
-        tokenData: mockTokenData,
-        price: '0.5',
-        xrpUSDRate: '2',
-        isHoldersDataLoading: false,
-      }),
-    )
-
-    expect(result.current.marketCap).toBeNull()
-  })
-
-  it('returns null marketCap when price is empty', () => {
-    const { result } = renderHook(() =>
-      useMarketCalculations({
-        holdersData: mockHoldersData,
-        tokenData: { ...mockTokenData, supply: '1000000' },
-        price: '',
-        xrpUSDRate: '2',
-        isHoldersDataLoading: false,
-      }),
-    )
-
-    expect(result.current.marketCap).toBeNull()
-  })
-
-  it('returns null marketCap when xrpUSDRate is empty', () => {
-    const { result } = renderHook(() =>
-      useMarketCalculations({
-        holdersData: mockHoldersData,
-        tokenData: { ...mockTokenData, supply: '1000000' },
-        price: '0.5',
-        xrpUSDRate: '',
-        isHoldersDataLoading: false,
-      }),
-    )
-
-    expect(result.current.marketCap).toBeNull()
-  })
-
-  it('calculates marketCap correctly with valid inputs', () => {
-    const { result } = renderHook(() =>
-      useMarketCalculations({
-        holdersData: mockHoldersData,
-        tokenData: { ...mockTokenData, supply: '1000000' },
-        price: '1',
-        xrpUSDRate: '2',
-        isHoldersDataLoading: false,
-      }),
-    )
-
-    // 1000000 * 1 * 2 = 2000000
-    expect(result.current.marketCap).toBeDefined()
-  })
-
-  it('handles zero price', () => {
-    const { result } = renderHook(() =>
-      useMarketCalculations({
-        holdersData: mockHoldersData,
-        tokenData: { ...mockTokenData, supply: '1000000' },
-        price: '0',
-        xrpUSDRate: '2',
-        isHoldersDataLoading: false,
-      }),
-    )
-
-    expect(result.current.marketCap).toBeNull()
-  })
-
-  it('handles zero xrpUSDRate', () => {
-    const { result } = renderHook(() =>
-      useMarketCalculations({
-        holdersData: mockHoldersData,
-        tokenData: { ...mockTokenData, supply: '1000000' },
-        price: '0.5',
-        xrpUSDRate: '0',
-        isHoldersDataLoading: false,
-      }),
-    )
-
-    expect(result.current.marketCap).toBeNull()
-  })
-
-  it('handles very small price values', () => {
-    const { result } = renderHook(() =>
-      useMarketCalculations({
-        holdersData: mockHoldersData,
-        tokenData: { ...mockTokenData, supply: '1000000' },
-        price: '0.0001',
-        xrpUSDRate: '2',
-        isHoldersDataLoading: false,
-      }),
-    )
-
-    expect(result.current.marketCap).toBeDefined()
-  })
-
-  it('handles very large price values', () => {
-    const { result } = renderHook(() =>
-      useMarketCalculations({
-        holdersData: mockHoldersData,
-        tokenData: { ...mockTokenData, supply: '1000000' },
-        price: '1000000',
-        xrpUSDRate: '2',
-        isHoldersDataLoading: false,
-      }),
-    )
-
-    expect(result.current.marketCap).toBeDefined()
-  })
-
-  it('formats circulating supply', () => {
-    const { result } = renderHook(() =>
-      useMarketCalculations({
-        holdersData: mockHoldersData,
-        tokenData: { ...mockTokenData, supply: '1000000' },
-        price: '0.5',
-        xrpUSDRate: '2',
-        isHoldersDataLoading: false,
-      }),
-    )
-
-    expect(result.current.formattedCircSupply).toBeDefined()
-    expect(typeof result.current.formattedCircSupply).toBe('string')
-  })
-
-  it('returns circSupply as number', () => {
-    const { result } = renderHook(() =>
-      useMarketCalculations({
-        holdersData: mockHoldersData,
-        tokenData: { ...mockTokenData, supply: '1000000' },
-        price: '0.5',
-        xrpUSDRate: '2',
-        isHoldersDataLoading: false,
-      }),
-    )
-
-    expect(typeof result.current.circSupply).toBe('number')
-  })
-
-  it('handles undefined holdersData', () => {
-    const { result } = renderHook(() =>
-      useMarketCalculations({
-        holdersData: undefined,
-        tokenData: { ...mockTokenData, supply: '1000000' },
-        price: '0.5',
-        xrpUSDRate: '2',
-        isHoldersDataLoading: false,
-      }),
-    )
-
-    expect(result.current.circSupply).toBe(1000000)
-  })
-
-  it('handles circ_supply in tokenData', () => {
-    const { result } = renderHook(() =>
-      useMarketCalculations({
-        holdersData: mockHoldersData,
-        tokenData: { ...mockTokenData, circ_supply: '500000' },
-        price: '0.5',
-        xrpUSDRate: '2',
-        isHoldersDataLoading: false,
-      }),
-    )
-
-    expect(result.current.circSupply).toBe(500000)
-  })
-
-  it('memoizes results correctly', () => {
-    const { result, rerender } = renderHook(
-      (props) => useMarketCalculations(props),
-      {
-        initialProps: {
-          holdersData: mockHoldersData,
-          tokenData: { ...mockTokenData, supply: '1000000' },
-          price: '0.5',
-          xrpUSDRate: '2',
-          isHoldersDataLoading: false,
-        },
-      },
-    )
-
-    const firstResult = result.current
-
-    rerender({
-      holdersData: mockHoldersData,
-      tokenData: { ...mockTokenData, supply: '1000000' },
-      price: '0.5',
-      xrpUSDRate: '2',
-      isHoldersDataLoading: false,
-    })
-
-    expect(result.current).toEqual(firstResult)
-  })
-
-  it('updates when dependencies change', () => {
-    const { result, rerender } = renderHook(
-      (props) => useMarketCalculations(props),
-      {
-        initialProps: {
-          holdersData: mockHoldersData,
-          tokenData: { ...mockTokenData, supply: '1000000' },
-          price: '0.5',
-          xrpUSDRate: '2',
-          isHoldersDataLoading: false,
-        },
-      },
-    )
-
-    const firstResult = result.current
-
-    rerender({
-      holdersData: mockHoldersData,
-      tokenData: { ...mockTokenData, supply: '2000000' },
-      price: '0.5',
-      xrpUSDRate: '2',
-      isHoldersDataLoading: false,
-    })
-
-    expect(result.current.circSupply).not.toEqual(firstResult.circSupply)
-  })
-})
diff --git a/src/containers/Token/IOU/test/utils/tokenCalculations.test.ts b/src/containers/Token/IOU/test/utils/tokenCalculations.test.ts
deleted file mode 100644
index 0e4701ccc..000000000
--- a/src/containers/Token/IOU/test/utils/tokenCalculations.test.ts
+++ /dev/null
@@ -1,217 +0,0 @@
-import {
-  calculateCirculatingSupply,
-  formatCirculatingSupply,
-} from '../../utils/tokenCalculations'
-import { TokenHoldersData } from '../../api/holders'
-import { LOSToken } from '../../../../shared/losTypes'
-
-describe('tokenCalculations', () => {
-  describe('calculateCirculatingSupply', () => {
-    const mockTokenData: LOSToken = {
-      currency: 'USD',
-      issuer_account: 'rIssuer',
-      trustlines: 100,
-      index: 0,
-    }
-
-    it('returns circ_supply from tokenData if available', () => {
-      const tokenData = {
-        ...mockTokenData,
-        circ_supply: '1000000',
-      }
-      const result = calculateCirculatingSupply(undefined, tokenData)
-      expect(result).toBe(1000000)
-    })
-
-    it('returns supply from tokenData when circ_supply is not available', () => {
-      const tokenData = {
-        ...mockTokenData,
-        supply: '5000000',
-      }
-      const result = calculateCirculatingSupply(undefined, tokenData)
-      expect(result).toBe(5000000)
-    })
-
-    it('returns totalSupply from holdersData when tokenData supply is not available', () => {
-      const holdersData: TokenHoldersData = {
-        totalSupply: 3000000,
-        totalHolders: 100,
-        holders: [],
-      }
-      const tokenData = {
-        ...mockTokenData,
-      }
-      const result = calculateCirculatingSupply(holdersData, tokenData)
-      expect(result).toBe(3000000)
-    })
-
-    it('returns 0 when no supply data is available', () => {
-      const tokenData = {
-        ...mockTokenData,
-      }
-      const result = calculateCirculatingSupply(undefined, tokenData)
-      expect(result).toBe(0)
-    })
-
-    it('subtracts large holders (>= 20%) for non-stablecoin tokens', () => {
-      const holdersData: TokenHoldersData = {
-        totalSupply: 1000000,
-        totalHolders: 5,
-        holders: [
-          { account: 'rHolder1', balance: 300000, percent: 30 },
-          { account: 'rHolder2', balance: 200000, percent: 20 },
-          { account: 'rHolder3', balance: 100000, percent: 10 },
-        ],
-      }
-      const tokenData = {
-        ...mockTokenData,
-        supply: '1000000',
-        asset_subclass: 'token',
-      }
-      const result = calculateCirculatingSupply(holdersData, tokenData)
-      // 1000000 - 300000 (30%) - 200000 (20%) = 500000
-      expect(result).toBe(500000)
-    })
-
-    it('does not subtract large holders for stablecoin tokens', () => {
-      const holdersData: TokenHoldersData = {
-        totalSupply: 1000000,
-        totalHolders: 5,
-        holders: [
-          { account: 'rHolder1', balance: 300000, percent: 30 },
-          { account: 'rHolder2', balance: 200000, percent: 20 },
-          { account: 'rHolder3', balance: 100000, percent: 10 },
-        ],
-      }
-      const tokenData = {
-        ...mockTokenData,
-        supply: '1000000',
-        asset_subclass: 'stablecoin',
-      }
-      const result = calculateCirculatingSupply(holdersData, tokenData)
-      // For stablecoins, no subtraction: 1000000
-      expect(result).toBe(1000000)
-    })
-
-    it('handles holders with exactly 20% threshold', () => {
-      const holdersData: TokenHoldersData = {
-        totalSupply: 1000000,
-        totalHolders: 5,
-        holders: [
-          { account: 'rHolder1', balance: 200000, percent: 20 },
-          { account: 'rHolder2', balance: 100000, percent: 10 },
-        ],
-      }
-      const tokenData = {
-        ...mockTokenData,
-        supply: '1000000',
-        asset_subclass: 'token',
-      }
-      const result = calculateCirculatingSupply(holdersData, tokenData)
-      // 1000000 - 200000 (20%) = 800000
-      expect(result).toBe(800000)
-    })
-
-    it('handles holders with less than 20% threshold', () => {
-      const holdersData: TokenHoldersData = {
-        totalSupply: 1000000,
-        totalHolders: 5,
-        holders: [
-          { account: 'rHolder1', balance: 190000, percent: 19 },
-          { account: 'rHolder2', balance: 100000, percent: 10 },
-        ],
-      }
-      const tokenData = {
-        ...mockTokenData,
-        supply: '1000000',
-        asset_subclass: 'token',
-      }
-      const result = calculateCirculatingSupply(holdersData, tokenData)
-      // No subtraction: 1000000
-      expect(result).toBe(1000000)
-    })
-
-    it('handles empty holders array', () => {
-      const holdersData: TokenHoldersData = {
-        totalSupply: 1000000,
-        totalHolders: 0,
-        holders: [],
-      }
-      const tokenData = {
-        ...mockTokenData,
-        supply: '1000000',
-        asset_subclass: 'token',
-      }
-      const result = calculateCirculatingSupply(holdersData, tokenData)
-      expect(result).toBe(1000000)
-    })
-
-    it('handles multiple large holders', () => {
-      const holdersData: TokenHoldersData = {
-        totalSupply: 1000000,
-        totalHolders: 10,
-        holders: [
-          { account: 'rHolder1', balance: 250000, percent: 25 },
-          { account: 'rHolder2', balance: 250000, percent: 25 },
-          { account: 'rHolder3', balance: 250000, percent: 25 },
-          { account: 'rHolder4', balance: 250000, percent: 25 },
-        ],
-      }
-      const tokenData = {
-        ...mockTokenData,
-        supply: '1000000',
-        asset_subclass: 'token',
-      }
-      const result = calculateCirculatingSupply(holdersData, tokenData)
-      // 1000000 - (250000 * 4) = 0
-      expect(result).toBe(0)
-    })
-
-    it('prioritizes circ_supply over supply', () => {
-      const holdersData: TokenHoldersData = {
-        totalSupply: 5000000,
-        totalHolders: 100,
-        holders: [],
-      }
-      const tokenData = {
-        ...mockTokenData,
-        circ_supply: '2000000',
-        supply: '3000000',
-      }
-      const result = calculateCirculatingSupply(holdersData, tokenData)
-      expect(result).toBe(2000000)
-    })
-  })
-
-  describe('formatCirculatingSupply', () => {
-    it('formats small numbers with full precision', () => {
-      const result = formatCirculatingSupply(100)
-      expect(result).toBe('100')
-    })
-
-    it('formats large numbers with abbreviation', () => {
-      const result = formatCirculatingSupply(1000000)
-      expect(result).toMatch(/1\.0M|1M/)
-    })
-
-    it('formats very large numbers with abbreviation', () => {
-      const result = formatCirculatingSupply(1000000000)
-      expect(result).toMatch(/1\.0B|1B/)
-    })
-
-    it('formats zero', () => {
-      const result = formatCirculatingSupply(0)
-      expect(result).toBe('0')
-    })
-
-    it('formats decimal numbers', () => {
-      const result = formatCirculatingSupply(1234.5678)
-      expect(result).toBeDefined()
-    })
-
-    it('handles very small numbers', () => {
-      const result = formatCirculatingSupply(0.0001)
-      expect(result).toBeDefined()
-    })
-  })
-})
diff --git a/src/containers/Token/IOU/utils/tokenCalculations.ts b/src/containers/Token/IOU/utils/tokenCalculations.ts
deleted file mode 100644
index 350b204eb..000000000
--- a/src/containers/Token/IOU/utils/tokenCalculations.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import { parseIntegerAmount } from '../../../shared/NumberFormattingUtils'
-import { TokenHoldersData } from '../api/holders'
-import { LOSToken } from '../../../shared/losTypes'
-
-/**
- * Calculates the circulating supply for a token
- * @param holdersData - Token holders data
- * @param tokenData - Token data
- * @returns Calculated circulating supply
- */
-export const calculateCirculatingSupply = (
-  holdersData: TokenHoldersData | undefined,
-  tokenData: LOSToken,
-): number => {
-  if (tokenData.circ_supply) {
-    return Number(tokenData.circ_supply)
-  }
-  let circSupply = Number(tokenData.supply) || holdersData?.totalSupply || 0
-
-  // For stablecoins, don't subtract large percentage holders from circulating supply
-  if (tokenData.asset_subclass !== 'stablecoin' && holdersData) {
-    holdersData.holders.forEach((holder) => {
-      if (holder.percent >= 20) {
-        circSupply -= holder.balance
-      }
-    })
-  }
-
-  return circSupply
-}
-
-/**
- * Formats the circulating supply for display
- * @param circSupply - The circulating supply number
- * @returns Formatted circulating supply string
- */
-export const formatCirculatingSupply = (circSupply: number): string =>
-  parseIntegerAmount(circSupply)
diff --git a/src/containers/Token/MPT/Header/GeneralOverview.tsx b/src/containers/Token/MPT/Header/GeneralOverview.tsx
index aa3d8e242..e4c688632 100644
--- a/src/containers/Token/MPT/Header/GeneralOverview.tsx
+++ b/src/containers/Token/MPT/Header/GeneralOverview.tsx
@@ -36,10 +36,10 @@ export const GeneralOverview = ({
       <div className="header-box-contents">
         <div className="header-box-item">
           <div className="item-name">{t('token_page.issuer')}</div>
-          <div className="item-value account-link">
+          <div className="item-value account-link issuer-value">
             <Account
               account={issuer}
-              displayText={shortenAccount(issuerName) || shortenAccount(issuer)}
+              displayText={issuerName || shortenAccount(issuer)}
             />
           </div>
         </div>
diff --git a/src/containers/Token/MPT/Header/MarketData.tsx b/src/containers/Token/MPT/Header/MarketData.tsx
index 8fe2c314e..7ad2777ce 100644
--- a/src/containers/Token/MPT/Header/MarketData.tsx
+++ b/src/containers/Token/MPT/Header/MarketData.tsx
@@ -5,29 +5,35 @@ import { Tooltip, useTooltip } from '../../../shared/components/Tooltip'
 import { ConfBalanceTooltipIcon } from '../../../shared/components/ConfBalanceTooltipIcon'
 
 interface MarketDataProps {
-  maxAmt?: string
   outstandingAmt?: string
   confidentialOutstandingAmt?: string
   assetScale?: number
+  // Circulating supply (outstanding minus large holders), scaled decimal string.
+  circulatingSupply?: string
+  circulatingSupplyLoading?: boolean
 }
 
 export const MarketData = ({
-  maxAmt,
   outstandingAmt,
   confidentialOutstandingAmt,
   assetScale,
+  circulatingSupply,
+  circulatingSupplyLoading,
 }: MarketDataProps): JSX.Element => {
   const { t } = useTranslation()
   const { tooltip } = useTooltip()
 
+  // Supply is the on-chain outstanding amount.
   const formattedSupply = parseAmount(
-    convertScaledPrice(BigInt(maxAmt || '0'), assetScale ?? 0),
-  )
-
-  const formattedCircSupply = parseAmount(
     convertScaledPrice(BigInt(outstandingAmt || '0'), assetScale ?? 0),
   )
 
+  // Circulating supply is derived from holder data. When that is unavailable
+  // (e.g. the holders request failed) show "--" rather than the unadjusted
+  // supply, which would look like a real circulating figure.
+  const formattedCircSupply =
+    circulatingSupply === undefined ? '--' : parseAmount(circulatingSupply)
+
   const formattedConfidentialAmt = confidentialOutstandingAmt
     ? parseAmount(
         convertScaledPrice(BigInt(confidentialOutstandingAmt), assetScale ?? 0),
@@ -45,7 +51,13 @@ export const MarketData = ({
         </div>
         <div className="header-box-item">
           <div className="item-name">{t('token_page.circulating_supply')}</div>
-          <div className="item-value">{formattedCircSupply}</div>
+          <div className="item-value">
+            {circulatingSupplyLoading ? (
+              <span className="loading-spinner" />
+            ) : (
+              formattedCircSupply
+            )}
+          </div>
         </div>
         {formattedConfidentialAmt && (
           <div className="header-box-item">
diff --git a/src/containers/Token/MPT/Header/Metadata.tsx b/src/containers/Token/MPT/Header/Metadata.tsx
index 2182abb3b..f37e86af2 100644
--- a/src/containers/Token/MPT/Header/Metadata.tsx
+++ b/src/containers/Token/MPT/Header/Metadata.tsx
@@ -1,5 +1,8 @@
 import { useTranslation } from 'react-i18next'
-import { JsonView } from '../../../shared/components/JsonView'
+import {
+  JsonView,
+  NO_STRING_COLLAPSE,
+} from '../../../shared/components/JsonView'
 
 interface MetadataProps {
   decodedMPTMetadata: Record<string, unknown> | string
@@ -22,7 +25,12 @@ export const Metadata = ({
         {isString ? (
           <div className="metadata-string">{decodedMPTMetadata}</div>
         ) : (
-          <JsonView data={decodedMPTMetadata} showExpandButton showBackground />
+          <JsonView
+            data={decodedMPTMetadata}
+            showExpandButton
+            showBackground
+            collapseStringsAfterLength={NO_STRING_COLLAPSE}
+          />
         )}
       </div>
     </div>
diff --git a/src/containers/Token/MPT/Header/index.tsx b/src/containers/Token/MPT/Header/index.tsx
index 74bed94d9..00106edc7 100644
--- a/src/containers/Token/MPT/Header/index.tsx
+++ b/src/containers/Token/MPT/Header/index.tsx
@@ -5,12 +5,13 @@ import './styles.scss'
 import {
   BAD_REQUEST,
   HASH192_REGEX,
-  shortenDomain,
   shortenMPTID,
-  stripHttpProtocol,
   convertToHttpURL,
-  shortenAccount,
 } from '../../../shared/utils'
+import {
+  getRegistrableDomain,
+  shortenDomainFromLeft,
+} from '../../../shared/domainUtils'
 import { CopyableText } from '../../../shared/components/CopyableText'
 import DomainLink from '../../../shared/components/DomainLink'
 import { FormattedMPTIssuance } from '../../../shared/Interfaces'
@@ -37,6 +38,8 @@ interface Props {
   setError: (error: number | null) => void
   holdersCount?: number
   holdersLoading?: boolean
+  circulatingSupply?: string
+  circulatingSupplyLoading?: boolean
 }
 
 export const Header = (props: Props) => {
@@ -48,6 +51,8 @@ export const Header = (props: Props) => {
     setError,
     holdersCount,
     holdersLoading,
+    circulatingSupply,
+    circulatingSupplyLoading,
   } = props
   const [showURLDropdown, setShowURLDropdown] = useState(false)
   const dropdownRef = useRef<HTMLDivElement>(null)
@@ -87,7 +92,6 @@ export const Header = (props: Props) => {
   const {
     issuer,
     assetScale,
-    maxAmt,
     outstandingAmt,
     confidentialOutstandingAmt,
     transferFee,
@@ -162,13 +166,6 @@ export const Header = (props: Props) => {
               />
             </span>
           )}
-          {/* Show issuer name if available */}
-          {issuerName && (
-            <div className="token-issuer-wrap">
-              (<span className="issuer-name">{shortenAccount(issuerName)}</span>
-              )
-            </div>
-          )}
         </div>
 
         {allUris.length > 0 && (
@@ -181,11 +178,10 @@ export const Header = (props: Props) => {
               <DomainLink
                 className="domain-link"
                 domain={allUris[0].uri}
-                displayDomain={shortenDomain(
-                  stripHttpProtocol(allUris[0].uri),
-                  12,
-                  7,
+                displayDomain={shortenDomainFromLeft(
+                  getRegistrableDomain(allUris[0].uri),
                 )}
+                title={allUris[0].uri}
               />
               {allUris.length > 1 && (
                 <button
@@ -203,11 +199,10 @@ export const Header = (props: Props) => {
                       key={`${uriItem.uri}-${uriItem.category}-${uriItem.title}`}
                       className="links-dropdown-item"
                       domain={uriItem.uri}
-                      displayDomain={shortenDomain(
-                        stripHttpProtocol(uriItem.uri),
-                        12,
-                        7,
+                      displayDomain={shortenDomainFromLeft(
+                        getRegistrableDomain(uriItem.uri),
                       )}
+                      title={uriItem.uri}
                       keepProtocol={false}
                     />
                   ))}
@@ -230,10 +225,11 @@ export const Header = (props: Props) => {
             holdersLoading={holdersLoading}
           />
           <MarketData
-            maxAmt={maxAmt}
             outstandingAmt={outstandingAmt}
             confidentialOutstandingAmt={confidentialOutstandingAmt}
             assetScale={assetScale}
+            circulatingSupply={circulatingSupply}
+            circulatingSupplyLoading={circulatingSupplyLoading}
           />
           <Settings flags={flags} />
           {(parsedMPTMetadata || rawMPTMetadata) && (
diff --git a/src/containers/Token/MPT/Header/styles.scss b/src/containers/Token/MPT/Header/styles.scss
index d239c2284..0134da28f 100644
--- a/src/containers/Token/MPT/Header/styles.scss
+++ b/src/containers/Token/MPT/Header/styles.scss
@@ -130,6 +130,12 @@
     overflow-wrap: break-word;
   }
 
+  // Full (untruncated) issuer name should wrap within the value column
+  // rather than overflow when it is long.
+  .issuer-value {
+    overflow-wrap: anywhere;
+  }
+
   // Settings box flag status styling
   .settings-box {
     .header-box-item {
diff --git a/src/containers/Token/MPT/api/holders.ts b/src/containers/Token/MPT/api/holders.ts
index c26fd82ae..cc3bc5f16 100644
--- a/src/containers/Token/MPT/api/holders.ts
+++ b/src/containers/Token/MPT/api/holders.ts
@@ -12,6 +12,8 @@ interface MPTHolder {
   rank: number
   account: string
   balance: string
+  // Unscaled on-chain amount, kept so supply math can stay exact (BigInt).
+  rawBalance: string
   percent: number
   value_usd: number | null
 }
@@ -76,6 +78,7 @@ export async function fetchAllMPTHolders(
         rank: index + 1,
         account: token.account,
         balance: convertScaledPrice(BigInt(token.mpt_amount || 0), assetScale),
+        rawBalance: balance.toString(10),
         percent,
         value_usd: null, // MPT doesn't have USD value yet
       }
diff --git a/src/containers/Token/MPT/index.tsx b/src/containers/Token/MPT/index.tsx
index cda087270..c65a9077e 100644
--- a/src/containers/Token/MPT/index.tsx
+++ b/src/containers/Token/MPT/index.tsx
@@ -24,6 +24,8 @@ import SocketContext from '../../shared/SocketContext'
 import { getMPTIssuance } from '../../../rippled/lib/rippled'
 import { formatMPTIssuance } from '../../../rippled/lib/utils'
 import { fetchAllMPTHolders } from './api/holders'
+import { calculateMptCirculatingSupply } from './utils/circulatingSupply'
+import { isRwaAssetClass } from '../shared/utils/circulatingSupply'
 import { paginationService as transfersPaginationService } from '../shared/services/transfersPagination'
 import { useCursorPaginatedQuery } from '../../shared/hooks/useCursorPaginatedQuery'
 import { PAGINATION_CONFIG, INITIAL_PAGE } from '../shared/constants'
@@ -85,9 +87,20 @@ export const MPT = () => {
       },
     )
 
-  // Fetch ALL holders data at once using mpt_holders Clio method
-  const { data: holdersData, isFetching: holdersLoading } = useQuery(
-    ['getMPTHolders', mptIssuanceId],
+  // Fetch ALL holders data at once using mpt_holders Clio method.
+  // Holder percentages/balances are derived from the outstanding amount and
+  // asset scale, so both belong in the query key.
+  const {
+    data: holdersData,
+    isFetching: holdersLoading,
+    isError: holdersError,
+  } = useQuery(
+    [
+      'getMPTHolders',
+      mptIssuanceId,
+      mptokenIssuance?.outstandingAmt,
+      mptokenIssuance?.assetScale,
+    ],
     async () =>
       fetchAllMPTHolders(
         rippledSocket,
@@ -100,6 +113,33 @@ export const MPT = () => {
     },
   )
 
+  // Circulating supply is only meaningful once holders resolve. While the fetch
+  // is pending (or hasn't started yet) show a spinner; if it failed, leave it
+  // undefined so the header renders "--" rather than the unadjusted supply.
+  const circulatingSupplyLoading =
+    holdersLoading || !(holdersData || holdersError)
+
+  // Circulating supply = outstanding amount minus large (>= 20%) holders, except
+  // for RWA tokens where those holders are custodians/treasuries (no exclusion).
+  const isRwa = isRwaAssetClass(mptokenIssuance?.parsedMPTMetadata?.asset_class)
+  const circulatingSupply = useMemo(
+    () =>
+      holdersData
+        ? calculateMptCirculatingSupply(
+            mptokenIssuance?.outstandingAmt,
+            mptokenIssuance?.assetScale ?? 0,
+            holdersData.holders,
+            isRwa,
+          )
+        : undefined,
+    [
+      holdersData,
+      mptokenIssuance?.outstandingAmt,
+      mptokenIssuance?.assetScale,
+      isRwa,
+    ],
+  )
+
   // Client-side pagination: slice the holders array for the current page
   const paginatedHolders = useMemo(() => {
     if (!holdersData?.holders) {
@@ -155,6 +195,8 @@ export const MPT = () => {
             setError={setError}
             holdersCount={holdersData?.totalHolders}
             holdersLoading={holdersLoading}
+            circulatingSupply={circulatingSupply}
+            circulatingSupplyLoading={circulatingSupplyLoading}
           />
         )
       )}
diff --git a/src/containers/Token/MPT/test/Header/GeneralOverview.test.tsx b/src/containers/Token/MPT/test/Header/GeneralOverview.test.tsx
index 28e97c237..612dea32a 100644
--- a/src/containers/Token/MPT/test/Header/GeneralOverview.test.tsx
+++ b/src/containers/Token/MPT/test/Header/GeneralOverview.test.tsx
@@ -44,6 +44,20 @@ describe('GeneralOverview component', () => {
     expect(container).toHaveTextContent('Test Issuer')
   })
 
+  it('displays the full issuer name untruncated (no address-style shortening)', () => {
+    const longName = 'Franklin Templeton Investments'
+    const { container } = renderComponent({ issuerName: longName })
+    // Full name should render; it must NOT be shortened to e.g. "Frankli...ments".
+    expect(container).toHaveTextContent(longName)
+    expect(container).not.toHaveTextContent('...')
+  })
+
+  it('falls back to the shortened account address when no issuer name', () => {
+    const { container } = renderComponent({ issuerName: undefined })
+    // shortenAccount keeps first 7 + last 5 chars of the address.
+    expect(container).toHaveTextContent('rTestIs...01234')
+  })
+
   it('displays transfer fee when provided', () => {
     const { container } = renderComponent({ transferFee: 1000 })
     // transferFee 1000 / 1000 = 1, formatted as percent = 1.000%
diff --git a/src/containers/Token/MPT/test/Header/Header.test.tsx b/src/containers/Token/MPT/test/Header/Header.test.tsx
index db0c4ffe4..14bf82363 100644
--- a/src/containers/Token/MPT/test/Header/Header.test.tsx
+++ b/src/containers/Token/MPT/test/Header/Header.test.tsx
@@ -51,6 +51,8 @@ describe('MPT Header component', () => {
             setError={props.setError || jest.fn()}
             holdersCount={props.holdersCount}
             holdersLoading={props.holdersLoading || false}
+            circulatingSupply={props.circulatingSupply}
+            circulatingSupplyLoading={props.circulatingSupplyLoading}
           />
         </Router>
       </I18nextProvider>,
@@ -158,4 +160,14 @@ describe('MPT Header component', () => {
     const { container } = renderComponent({ data: mockMPTData })
     expect(container.querySelectorAll('.metadata-box')).toHaveLength(1)
   })
+
+  it('renders the circulating supply when provided', () => {
+    const { container } = renderComponent({
+      data: mockMPTData,
+      circulatingSupply: '3000',
+    })
+    // mockMPTData: outstandingAmt 500000 / 10^2 = 5,000.00 (Supply)
+    // circulatingSupply 3000 -> 3,000.00 (Circ Supply)
+    expect(container).toHaveTextContent('3,000.00')
+  })
 })
diff --git a/src/containers/Token/MPT/test/Header/MarketData.test.tsx b/src/containers/Token/MPT/test/Header/MarketData.test.tsx
index e60aa7198..ce4e1f65a 100644
--- a/src/containers/Token/MPT/test/Header/MarketData.test.tsx
+++ b/src/containers/Token/MPT/test/Header/MarketData.test.tsx
@@ -8,10 +8,11 @@ describe('MarketData component', () => {
     render(
       <I18nextProvider i18n={i18n}>
         <MarketData
-          maxAmt={props.maxAmt}
           outstandingAmt={props.outstandingAmt}
           confidentialOutstandingAmt={props.confidentialOutstandingAmt}
           assetScale={props.assetScale}
+          circulatingSupply={props.circulatingSupply}
+          circulatingSupplyLoading={props.circulatingSupplyLoading}
         />
       </I18nextProvider>,
     )
@@ -34,40 +35,70 @@ describe('MarketData component', () => {
     expect(container).toHaveTextContent('token_page.circulating_supply')
   })
 
-  it('displays formatted max amount with scale 0', () => {
+  it('shows Supply from the outstanding amount', () => {
     const { container } = renderComponent({
-      maxAmt: '1000000',
+      outstandingAmt: '5000000',
       assetScale: 0,
     })
-    // parseAmount abbreviates large numbers
-    expect(container).toHaveTextContent('1.0M')
+    const values = container.querySelectorAll('.item-value')
+    // Row 0 = Supply.
+    expect(values[0]).toHaveTextContent('5.0M')
   })
 
-  it('displays formatted max amount with scale 2', () => {
+  it('shows Circ Supply from the circulatingSupply prop, distinct from Supply', () => {
     const { container } = renderComponent({
-      maxAmt: '100000000',
-      assetScale: 2,
+      outstandingAmt: '5000000',
+      circulatingSupply: '3000000',
+      assetScale: 0,
     })
-    // 100000000 with scale 2 = 1000000, formatted as 1.0M
-    expect(container).toHaveTextContent('1.0M')
+    const values = container.querySelectorAll('.item-value')
+    expect(values[0]).toHaveTextContent('5.0M') // Supply = outstanding
+    expect(values[1]).toHaveTextContent('3.0M') // Circ Supply = prop
   })
 
-  it('displays formatted outstanding amount', () => {
+  it('shows -- for Circ Supply when it is unavailable (e.g. holders failed)', () => {
     const { container } = renderComponent({
       outstandingAmt: '5000000',
+      circulatingSupply: undefined,
       assetScale: 0,
     })
-    // parseAmount abbreviates large numbers
-    expect(container).toHaveTextContent('5.0M')
+    const values = container.querySelectorAll('.item-value')
+    // Supply still renders; Circ Supply must not silently show the unadjusted
+    // supply, which would look like a real circulating figure.
+    expect(values[0]).toHaveTextContent('5.0M')
+    expect(values[1]).toHaveTextContent('--')
   })
 
-  it('displays 0 for undefined amounts', () => {
+  it('shows a spinner for Circ Supply while it is loading', () => {
     const { container } = renderComponent({
-      maxAmt: undefined,
-      outstandingAmt: undefined,
+      outstandingAmt: '5000000',
+      circulatingSupplyLoading: true,
+      assetScale: 0,
+    })
+    const values = container.querySelectorAll('.item-value')
+    // Supply still renders; Circ Supply shows a spinner instead of a value.
+    expect(values[0]).toHaveTextContent('5.0M')
+    expect(values[1].querySelectorAll('.loading-spinner')).toHaveLength(1)
+  })
+
+  it('defaults an undefined asset scale to 0', () => {
+    const { container } = renderComponent({
+      outstandingAmt: '5000000',
+      circulatingSupply: '5000000',
       assetScale: undefined,
     })
-    expect(container).toHaveTextContent('0')
+    const values = container.querySelectorAll('.item-value')
+    expect(values[0]).toHaveTextContent('5.0M')
+    expect(values[1]).toHaveTextContent('5.0M')
+  })
+
+  it('displays circulating supply of 0 for undefined amounts', () => {
+    const { container } = renderComponent({
+      outstandingAmt: undefined,
+      circulatingSupply: '0',
+      assetScale: 0,
+    })
+    expect(container).toHaveTextContent('0.00')
   })
 
   it('displays market cap placeholder', () => {
diff --git a/src/containers/Token/MPT/test/Header/Metadata.test.tsx b/src/containers/Token/MPT/test/Header/Metadata.test.tsx
index 9b2dcfe93..694caecea 100644
--- a/src/containers/Token/MPT/test/Header/Metadata.test.tsx
+++ b/src/containers/Token/MPT/test/Header/Metadata.test.tsx
@@ -46,6 +46,17 @@ describe('Metadata component', () => {
     expect(container.querySelectorAll('.metadata-json')).toHaveLength(1)
   })
 
+  it('renders long URI strings in full without truncation', () => {
+    const longUri =
+      'https://www.franklintempleton.com/about-us/our-teams/specialist-investment-managers/digital-assets/digital-assets-technology'
+    const metadata = {
+      uris: [{ uri: longUri, category: 'website', title: 'Main' }],
+    }
+    const { container } = renderComponent({ decodedMPTMetadata: metadata })
+    // The full URI must be present (JsonView string collapsing is disabled here).
+    expect(container).toHaveTextContent(longUri)
+  })
+
   it('handles complex nested metadata', () => {
     const metadata = {
       ticker: 'TEST',
diff --git a/src/containers/Token/MPT/test/utils/circulatingSupply.test.ts b/src/containers/Token/MPT/test/utils/circulatingSupply.test.ts
new file mode 100644
index 000000000..94015ee3c
--- /dev/null
+++ b/src/containers/Token/MPT/test/utils/circulatingSupply.test.ts
@@ -0,0 +1,111 @@
+import { calculateMptCirculatingSupply } from '../../utils/circulatingSupply'
+
+describe('calculateMptCirculatingSupply', () => {
+  it('returns the scaled outstanding amount when there are no holders', () => {
+    expect(calculateMptCirculatingSupply('1000000', 0, undefined, false)).toBe(
+      '1000000',
+    )
+  })
+
+  it('applies the asset scale to the outstanding amount', () => {
+    // 281380138 / 10^7 = 28.1380138
+    expect(calculateMptCirculatingSupply('281380138', 7, [], false)).toBe(
+      '28.1380138',
+    )
+  })
+
+  it('subtracts a holder at or above the 20% threshold', () => {
+    expect(
+      calculateMptCirculatingSupply(
+        '1000000',
+        0,
+        [{ percent: 30, rawBalance: '300000' }],
+        false,
+      ),
+    ).toBe('700000')
+  })
+
+  it('ignores holders below the 20% threshold', () => {
+    expect(
+      calculateMptCirculatingSupply(
+        '1000000',
+        0,
+        [{ percent: 10, rawBalance: '300000' }],
+        false,
+      ),
+    ).toBe('1000000')
+  })
+
+  it('subtracts every large holder', () => {
+    expect(
+      calculateMptCirculatingSupply(
+        '1000000',
+        0,
+        [
+          { percent: 50, rawBalance: '500000' },
+          { percent: 20, rawBalance: '200000' },
+          { percent: 5, rawBalance: '50000' },
+        ],
+        false,
+      ),
+    ).toBe('300000')
+  })
+
+  it('does NOT subtract large holders for RWA tokens', () => {
+    expect(
+      calculateMptCirculatingSupply(
+        '1000000',
+        0,
+        [{ percent: 90, rawBalance: '900000' }],
+        true, // isRwa
+      ),
+    ).toBe('1000000')
+  })
+
+  it('returns exactly 0 (not a float residue) when large holders hold everything', () => {
+    // Regression: the previous Number-based math returned 2.3283064365386963e-10
+    // for these inputs, which parseAmount rendered as "< 0.0001" instead of "0.00".
+    expect(
+      calculateMptCirculatingSupply(
+        '2438827633859',
+        6,
+        [
+          { percent: 40.86, rawBalance: '996733784676' },
+          { percent: 24.44, rawBalance: '596075534821' },
+          { percent: 34.68, rawBalance: '846018314362' },
+        ],
+        false,
+      ),
+    ).toBe('0')
+  })
+
+  it('stays exact for amounts beyond double precision', () => {
+    // UInt64 max (2^63-1) exceeds Number.MAX_SAFE_INTEGER; a Number-based
+    // subtraction would lose the trailing digits.
+    expect(
+      calculateMptCirculatingSupply(
+        '9223372036854775807',
+        0,
+        [{ percent: 50, rawBalance: '9223372036854775800' }],
+        false,
+      ),
+    ).toBe('7')
+  })
+
+  it('floors at 0 instead of going negative', () => {
+    expect(
+      calculateMptCirculatingSupply(
+        '100',
+        0,
+        [{ percent: 100, rawBalance: '200' }],
+        false,
+      ),
+    ).toBe('0')
+  })
+
+  it('treats a missing outstanding amount as 0', () => {
+    expect(calculateMptCirculatingSupply(undefined, 0, undefined, false)).toBe(
+      '0',
+    )
+  })
+})
diff --git a/src/containers/Token/MPT/utils/circulatingSupply.ts b/src/containers/Token/MPT/utils/circulatingSupply.ts
new file mode 100644
index 000000000..90784dd01
--- /dev/null
+++ b/src/containers/Token/MPT/utils/circulatingSupply.ts
@@ -0,0 +1,44 @@
+import { convertScaledPrice } from '../../../shared/utils'
+import { isLargeHolder } from '../../shared/utils/circulatingSupply'
+
+interface MptHolderShare {
+  percent: number
+  // Unscaled on-chain amount.
+  rawBalance: string
+}
+
+/**
+ * Calculates an MPToken's circulating supply: the on-chain outstanding amount
+ * with the balances of large (>= 20%) holders removed.
+ *
+ * For RWA tokens the large holders are typically custodians/treasuries whose
+ * balances are still legitimately part of supply, so the exclusion is skipped —
+ * the same rule the IOU page uses. RWA is detected from the on-chain
+ * `asset_class` metadata; stablecoins are an RWA subclass, so this class check
+ * covers them too.
+ *
+ * @param outstandingAmt - Raw (unscaled) on-chain OutstandingAmount.
+ * @param assetScale - The issuance's asset scale.
+ * @param holders - Holders with their unscaled `rawBalance` and `percent`.
+ * @param isRwa - Whether the token's asset_class is 'rwa' (skip the exclusion).
+ * @returns The circulating supply as a scaled decimal string.
+ */
+export const calculateMptCirculatingSupply = (
+  outstandingAmt: string | undefined,
+  assetScale: number,
+  holders: readonly MptHolderShare[] | undefined,
+  isRwa: boolean,
+): string => {
+  const outstanding = BigInt(outstandingAmt || '0')
+  const circulating = isRwa
+    ? outstanding
+    : (holders ?? []).reduce(
+        (remaining, holder) =>
+          isLargeHolder(holder.percent)
+            ? remaining - BigInt(holder.rawBalance || '0')
+            : remaining,
+        outstanding,
+      )
+
+  return convertScaledPrice(circulating < 0n ? 0n : circulating, assetScale)
+}
diff --git a/src/containers/Token/shared/test/utils/circulatingSupply.test.ts b/src/containers/Token/shared/test/utils/circulatingSupply.test.ts
new file mode 100644
index 000000000..e9f460f52
--- /dev/null
+++ b/src/containers/Token/shared/test/utils/circulatingSupply.test.ts
@@ -0,0 +1,133 @@
+import {
+  LARGE_HOLDER_THRESHOLD_PERCENT,
+  calculateIouCirculatingSupply,
+  isLargeHolder,
+  isRwaAssetClass,
+  subtractLargeHolderBalances,
+} from '../../utils/circulatingSupply'
+
+describe('isLargeHolder', () => {
+  it('is true at or above the threshold', () => {
+    expect(isLargeHolder(LARGE_HOLDER_THRESHOLD_PERCENT)).toBe(true)
+    expect(isLargeHolder(99)).toBe(true)
+  })
+
+  it('is false below the threshold', () => {
+    expect(isLargeHolder(19.99)).toBe(false)
+    expect(isLargeHolder(0)).toBe(false)
+  })
+})
+
+describe('subtractLargeHolderBalances', () => {
+  it('returns supply unchanged when there are no holders', () => {
+    expect(subtractLargeHolderBalances(1000, undefined)).toBe(1000)
+    expect(subtractLargeHolderBalances(1000, [])).toBe(1000)
+  })
+
+  it('subtracts a single holder at or above the threshold', () => {
+    expect(
+      subtractLargeHolderBalances(1000, [{ percent: 25, balance: 300 }]),
+    ).toBe(700)
+  })
+
+  it('ignores holders below the threshold', () => {
+    expect(
+      subtractLargeHolderBalances(1000, [{ percent: 19.99, balance: 300 }]),
+    ).toBe(1000)
+  })
+
+  it('treats exactly the threshold as a large holder', () => {
+    expect(
+      subtractLargeHolderBalances(1000, [
+        { percent: LARGE_HOLDER_THRESHOLD_PERCENT, balance: 200 },
+      ]),
+    ).toBe(800)
+  })
+
+  it('subtracts every large holder but keeps small ones', () => {
+    expect(
+      subtractLargeHolderBalances(1000, [
+        { percent: 50, balance: 500 },
+        { percent: 20, balance: 200 },
+        { percent: 5, balance: 50 },
+      ]),
+    ).toBe(300)
+  })
+})
+
+describe('isRwaAssetClass', () => {
+  it('is true for the lowercase "rwa" asset class', () => {
+    expect(isRwaAssetClass('rwa')).toBe(true)
+  })
+
+  it('is false for other asset classes and undefined', () => {
+    expect(isRwaAssetClass('other')).toBe(false)
+    expect(isRwaAssetClass('US Treasuries')).toBe(false)
+    expect(isRwaAssetClass(undefined)).toBe(false)
+  })
+
+  it('is false (never throws) for non-string values from untrusted metadata', () => {
+    // asset_class is issuer-authored JSON; a non-string must compare unequal,
+    // not blow up on a string method.
+    expect(isRwaAssetClass(123)).toBe(false)
+    expect(isRwaAssetClass(null)).toBe(false)
+    expect(isRwaAssetClass({ rwa: true })).toBe(false)
+    expect(isRwaAssetClass(['rwa'])).toBe(false)
+  })
+
+  it('matches strictly — the XLS-89 asset_class is always lowercase', () => {
+    expect(isRwaAssetClass('RWA')).toBe(false)
+    expect(isRwaAssetClass(' rwa ')).toBe(false)
+  })
+})
+
+describe('calculateIouCirculatingSupply', () => {
+  const holdersData = {
+    totalSupply: 1000,
+    holders: [
+      { percent: 25, balance: 250 },
+      { percent: 15, balance: 150 },
+    ],
+  }
+
+  it('prefers the reported circulating supply when present', () => {
+    expect(
+      calculateIouCirculatingSupply(
+        { supply: '1000', circ_supply: '800' },
+        holdersData,
+      ),
+    ).toBe(800)
+  })
+
+  it('subtracts large holders from the reported supply', () => {
+    expect(calculateIouCirculatingSupply({ supply: '1000' }, holdersData)).toBe(
+      750,
+    )
+  })
+
+  it('falls back to the holders total supply when supply is missing', () => {
+    expect(calculateIouCirculatingSupply({}, holdersData)).toBe(750)
+  })
+
+  it('does not subtract large holders for RWA tokens (incl. stablecoins, an RWA subclass)', () => {
+    expect(
+      calculateIouCirculatingSupply(
+        { supply: '1000', asset_class: 'rwa' },
+        holdersData,
+      ),
+    ).toBe(1000)
+  })
+
+  it('still subtracts for non-RWA asset classes', () => {
+    expect(
+      calculateIouCirculatingSupply(
+        { supply: '1000', asset_class: 'memes' },
+        holdersData,
+      ),
+    ).toBe(750)
+  })
+
+  it('returns 0 when there is no supply data at all', () => {
+    expect(calculateIouCirculatingSupply({}, undefined)).toBe(0)
+  })
+})
diff --git a/src/containers/Token/shared/utils/circulatingSupply.ts b/src/containers/Token/shared/utils/circulatingSupply.ts
new file mode 100644
index 000000000..827ec36ee
--- /dev/null
+++ b/src/containers/Token/shared/utils/circulatingSupply.ts
@@ -0,0 +1,98 @@
+// Holders owning at least this percentage of the supply are treated as
+// non-circulating (issuer / treasury / whale wallets) and excluded from the
+// circulating supply estimate. Shared by the IOU and MPT token pages.
+export const LARGE_HOLDER_THRESHOLD_PERCENT = 20
+
+// Asset class (from token metadata) whose large holders — treasuries /
+// custodians — are legitimately part of circulating supply, so the large-holder
+// exclusion is skipped. Shared by the IOU and MPT token pages. Stablecoins are
+// an RWA subclass, so this class check covers them too.
+export const RWA_ASSET_CLASS = 'rwa'
+
+/**
+ * Whether a holder's share is large enough to be treated as non-circulating.
+ *
+ * @param percent - The holder's percentage of supply.
+ * @returns true when the holder meets the large-holder threshold.
+ */
+export const isLargeHolder = (percent: number): boolean =>
+  percent >= LARGE_HOLDER_THRESHOLD_PERCENT
+
+/**
+ * Whether a token's asset class marks it as a real-world asset.
+ *
+ * Accepts `unknown` because `asset_class` comes from issuer-authored metadata:
+ * it's compared directly against the lowercase XLS-89 value, so a non-string
+ * (or missing) value simply compares unequal — no coercion or method calls, so
+ * nothing to throw on.
+ *
+ * @param assetClass - The token's asset_class metadata value (untrusted).
+ * @returns true when the token is an RWA.
+ */
+export const isRwaAssetClass = (assetClass: unknown): boolean =>
+  assetClass === RWA_ASSET_CLASS
+
+interface HolderShare {
+  percent: number
+  balance: number
+}
+
+/**
+ * Subtracts the balances of "large" holders (>= LARGE_HOLDER_THRESHOLD_PERCENT
+ * of supply) from a token's total supply to estimate its circulating supply.
+ *
+ * @param supply - The token's total supply.
+ * @param holders - Holder balances with their percentage of supply.
+ * @returns The supply with large-holder balances removed.
+ */
+export const subtractLargeHolderBalances = (
+  supply: number,
+  holders: readonly HolderShare[] | undefined,
+): number =>
+  (holders ?? []).reduce(
+    (circulating, holder) =>
+      isLargeHolder(holder.percent)
+        ? circulating - holder.balance
+        : circulating,
+    supply,
+  )
+
+interface IouTokenSupplyData {
+  supply?: string
+  circ_supply?: string
+  asset_class?: string
+}
+
+interface IouHoldersData {
+  totalSupply: number
+  holders: readonly HolderShare[]
+}
+
+/**
+ * Calculates an IOU token's circulating supply.
+ *
+ * Uses the reported circulating supply when present; otherwise subtracts large
+ * holders from total supply — skipped for RWA tokens, whose large holders are
+ * custodial treasuries. Stablecoins are an RWA subclass, so the same
+ * `asset_class === 'rwa'` check covers them.
+ *
+ * @param tokenData - Token supply and asset-classification fields.
+ * @param holdersData - Holder balances, used as a supply fallback.
+ * @returns The circulating supply.
+ */
+export const calculateIouCirculatingSupply = (
+  tokenData: IouTokenSupplyData,
+  holdersData: IouHoldersData | undefined,
+): number => {
+  if (tokenData.circ_supply) {
+    return Number(tokenData.circ_supply)
+  }
+
+  const supply = Number(tokenData.supply) || holdersData?.totalSupply || 0
+
+  if (isRwaAssetClass(tokenData.asset_class)) {
+    return supply
+  }
+
+  return subtractLargeHolderBalances(supply, holdersData?.holders)
+}
diff --git a/src/containers/shared/components/DomainLink.tsx b/src/containers/shared/components/DomainLink.tsx
index a79d25d30..078f77ca8 100644
--- a/src/containers/shared/components/DomainLink.tsx
+++ b/src/containers/shared/components/DomainLink.tsx
@@ -7,6 +7,7 @@ export interface Props {
   domain: string
   displayDomain?: string
   keepProtocol?: boolean
+  title?: string
 }
 
 // Matches a protocol (e.g. 'http://' or 'https://') at the start of a string.
@@ -20,6 +21,7 @@ const DomainLink = (props: Props) => {
     domain,
     displayDomain = '',
     keepProtocol = true,
+    title,
   } = props
 
   // If decode is true, decode the domain
@@ -45,6 +47,7 @@ const DomainLink = (props: Props) => {
       rel="noopener noreferrer"
       target="_blank"
       href={href}
+      title={title}
       onClick={(event) => event.stopPropagation()}
     >
       {displayDomain || domainText}
diff --git a/src/containers/shared/components/JsonView/JsonView.tsx b/src/containers/shared/components/JsonView/JsonView.tsx
index 9f4ff60d9..eb622dbc1 100644
--- a/src/containers/shared/components/JsonView/JsonView.tsx
+++ b/src/containers/shared/components/JsonView/JsonView.tsx
@@ -6,16 +6,26 @@ import './json-view.scss'
 import CollapseAllIcon from '../../images/collapse_all.svg'
 import ExpandAllIcon from '../../images/expand_all.svg'
 
+// Sentinel for `collapseStringsAfterLength` that disables string collapsing.
+// It must be a large positive number: react18-json-view clamps the value with
+// `> 0 ? value : 0`, so 0 (and non-finite values like Infinity) would collapse
+// everything instead of nothing.
+export const NO_STRING_COLLAPSE = Number.MAX_SAFE_INTEGER
+
 interface JsonViewProps {
   data: any
   showExpandButton?: boolean
   showBackground?: boolean
+  // Strings longer than this are collapsed/truncated in the tree.
+  // Pass NO_STRING_COLLAPSE to render long strings (URIs, etc.) in full.
+  collapseStringsAfterLength?: number
 }
 
 export const JsonView = ({
   data,
   showExpandButton = false,
   showBackground = false,
+  collapseStringsAfterLength = 65,
 }: JsonViewProps) => {
   const { t } = useTranslation()
   const [isExpanded, setIsExpanded] = useState(false)
@@ -46,7 +56,7 @@ export const JsonView = ({
       <ReactJson
         src={data}
         collapsed={isExpanded ? false : 5}
-        collapseStringsAfterLength={65}
+        collapseStringsAfterLength={collapseStringsAfterLength}
         customizeNode={(params) => {
           if (params.node === undefined)
             return { className: 'json-view--undefined' }
diff --git a/src/containers/shared/components/test/DomainLink.test.tsx b/src/containers/shared/components/test/DomainLink.test.tsx
index 2f2993fb1..feca756d9 100644
--- a/src/containers/shared/components/test/DomainLink.test.tsx
+++ b/src/containers/shared/components/test/DomainLink.test.tsx
@@ -79,4 +79,18 @@ describe('DomainLink', () => {
     expect(link).toHaveTextContent('Custom Display Text')
     expect(link).toHaveAttribute('href', 'https://bithomp.com')
   })
+
+  it('sets the title attribute (full URL tooltip) when provided', () => {
+    const fullUrl = 'https://www.franklintempleton.com/about-us/our-teams'
+    render(
+      <DomainLink
+        domain={fullUrl}
+        displayDomain="franklintempleton.com"
+        title={fullUrl}
+      />,
+    )
+    const link = screen.getByRole('link')
+    expect(link).toHaveTextContent('franklintempleton.com')
+    expect(link).toHaveAttribute('title', fullUrl)
+  })
 })
diff --git a/src/containers/shared/domainUtils.ts b/src/containers/shared/domainUtils.ts
new file mode 100644
index 000000000..c6a1db6db
--- /dev/null
+++ b/src/containers/shared/domainUtils.ts
@@ -0,0 +1,67 @@
+import { getDomain } from 'tldts'
+
+/**
+ * Extracts the registrable domain (eTLD+1) from a URL, dropping the scheme,
+ * `www`, any subdomains, the path, and the query string.
+ *
+ * Uses a real public suffix list (via `tldts`) so multi-part suffixes are
+ * handled correctly — e.g. `sub.thing.co.uk` resolves to `thing.co.uk`, not
+ * `co.uk`. For inputs without a registrable domain (bare hostnames, `ipfs://`
+ * URIs, etc.) it falls back to the host portion of the string.
+ *
+ * @example
+ * getRegistrableDomain('https://www.franklintempleton.com/about-us/x') // 'franklintempleton.com'
+ * getRegistrableDomain('https://sub.thing.co.uk/path?q=1')             // 'thing.co.uk'
+ *
+ * @param url - The URL (or bare domain) to parse.
+ * @returns The registrable domain, or a best-effort host fallback.
+ */
+export const getRegistrableDomain = (url = ''): string => {
+  if (!url) {
+    return url
+  }
+
+  const domain = getDomain(url)
+  if (domain) {
+    return domain
+  }
+
+  // Fallback for inputs tldts can't resolve to a registrable domain
+  // (e.g. `ipfs://…`, `localhost`): strip any leading scheme and path/query.
+  const host = url.replace(/^[a-z][a-z0-9+.-]*:\/\//i, '').split(/[/?#]/)[0]
+  return host || url
+}
+
+/**
+ * Truncates a domain from the LEFT with a leading ellipsis so the TLD — the
+ * part people rely on to judge a link — always survives.
+ *
+ * @example
+ * shortenDomainFromLeft('a-very-long-domain-name.example.com', 24) // '…domain-name.example.com'
+ *
+ * @param domain - The domain to shorten.
+ * @param maxLength - Maximum rendered length, including the ellipsis. Defaults to 26.
+ * @returns The domain, left-truncated with a leading `…` when it overflows.
+ */
+export const shortenDomainFromLeft = (domain = '', maxLength = 26): string =>
+  domain.length > maxLength ? `…${domain.slice(-(maxLength - 1))}` : domain
+
+/**
+ * Middle-truncates a string, keeping the start and end (e.g.
+ * `verylongdomainn...dslimit.com`). Suited to resource URIs — such as NFT URLs —
+ * where the trailing path/filename distinguishes entries and is worth keeping
+ * visible, unlike the registrable-domain treatment used for website chips.
+ *
+ * @param domain - The string to shorten.
+ * @param prefixLength - Characters to keep from the start.
+ * @param suffixLength - Characters to keep from the end.
+ * @returns The string, middle-truncated with `...` when it overflows.
+ */
+export const shortenDomain = (
+  domain = '',
+  prefixLength = 15,
+  suffixLength = 11,
+): string =>
+  domain.length > prefixLength + suffixLength
+    ? `${domain.slice(0, prefixLength)}...${domain.slice(-suffixLength)}`
+    : domain
diff --git a/src/containers/shared/test/domainUtils.test.ts b/src/containers/shared/test/domainUtils.test.ts
new file mode 100644
index 000000000..7c310a29f
--- /dev/null
+++ b/src/containers/shared/test/domainUtils.test.ts
@@ -0,0 +1,82 @@
+import {
+  getRegistrableDomain,
+  shortenDomain,
+  shortenDomainFromLeft,
+} from '../domainUtils'
+
+describe('getRegistrableDomain', () => {
+  it('reduces a full URL to its registrable domain', () => {
+    expect(
+      getRegistrableDomain(
+        'https://www.franklintempleton.com/about-us/our-teams/specialist-investment-managers/digital-assets/',
+      ),
+    ).toBe('franklintempleton.com')
+  })
+
+  it('drops the scheme, www, subdomains, path, and query', () => {
+    expect(getRegistrableDomain('https://a.b.c.example.com/x?y=1#z')).toBe(
+      'example.com',
+    )
+  })
+
+  it('keeps multi-part public suffixes (does not collapse thing.co.uk to co.uk)', () => {
+    expect(getRegistrableDomain('https://sub.thing.co.uk/path?q=1')).toBe(
+      'thing.co.uk',
+    )
+    expect(getRegistrableDomain('thing.co.uk')).toBe('thing.co.uk')
+  })
+
+  it('handles a bare domain without a scheme', () => {
+    expect(getRegistrableDomain('franklintempleton.com')).toBe(
+      'franklintempleton.com',
+    )
+  })
+
+  it('falls back to the host for inputs without a registrable domain', () => {
+    // ipfs URIs have no public suffix; fall back to the first path segment.
+    expect(getRegistrableDomain('ipfs://QmHash/file.json')).toBe('QmHash')
+    // localhost has no public suffix.
+    expect(getRegistrableDomain('http://localhost:3000/x')).toBe(
+      'localhost:3000',
+    )
+  })
+
+  it('returns the input unchanged when empty', () => {
+    expect(getRegistrableDomain('')).toBe('')
+  })
+})
+
+describe('shortenDomainFromLeft', () => {
+  it('returns the domain unchanged when within the max length', () => {
+    expect(shortenDomainFromLeft('franklintempleton.com', 30)).toBe(
+      'franklintempleton.com',
+    )
+  })
+
+  it('truncates from the left with a leading ellipsis, preserving the TLD', () => {
+    const result = shortenDomainFromLeft(
+      'a-very-long-domain-name-that-overflows.example.com',
+      24,
+    )
+    expect(result.startsWith('…')).toBe(true)
+    expect(result).toHaveLength(24)
+    // The TLD survives the truncation.
+    expect(result.endsWith('example.com')).toBe(true)
+  })
+
+  it('handles an empty string', () => {
+    expect(shortenDomainFromLeft('')).toBe('')
+  })
+})
+
+describe('shortenDomain', () => {
+  it('shortens long domain names', () => {
+    const longDomain = 'verylongdomainnamethatexceedslimit.com'
+    expect(shortenDomain(longDomain)).toBe('verylongdomainn...dslimit.com')
+  })
+
+  it('returns short domain names unchanged', () => {
+    const shortDomain = 'example.com'
+    expect(shortenDomain(shortDomain)).toBe(shortDomain)
+  })
+})
diff --git a/src/containers/shared/test/utils.test.ts b/src/containers/shared/test/utils.test.ts
index 1227abc40..97f899510 100644
--- a/src/containers/shared/test/utils.test.ts
+++ b/src/containers/shared/test/utils.test.ts
@@ -9,7 +9,6 @@ import {
   formatDurationDetailed,
   formatAsset,
   shortenAccount,
-  shortenDomain,
   shortenNFTTokenID,
   shortenMPTID,
   shortenLPToken,
@@ -236,18 +235,6 @@ describe('Shorten utils', () => {
     })
   })
 
-  describe('shortenDomain', () => {
-    it('shortens long domain names', () => {
-      const longDomain = 'verylongdomainnamethatexceedslimit.com'
-      expect(shortenDomain(longDomain)).toBe('verylongdomainn...dslimit.com')
-    })
-
-    it('returns short domain names unchanged', () => {
-      const shortDomain = 'example.com'
-      expect(shortenDomain(shortDomain)).toBe(shortDomain)
-    })
-  })
-
   describe('shortenNFTTokenID', () => {
     it('shortens long NFT token IDs', () => {
       const longTokenID =
diff --git a/src/containers/shared/utils.js b/src/containers/shared/utils.js
index ab2e53b50..1710f99e7 100644
--- a/src/containers/shared/utils.js
+++ b/src/containers/shared/utils.js
@@ -560,15 +560,6 @@ export const shortenEncryptionKey = (key = '') =>
 
 export const stripHttpProtocol = (url = '') => url.replace(/^https?:\/\//, '')
 
-export const shortenDomain = (
-  domain = '',
-  prefixLength = 15,
-  suffixLength = 11,
-) =>
-  domain.length > prefixLength + suffixLength
-    ? `${domain.slice(0, prefixLength)}...${domain.slice(-suffixLength)}`
-    : domain
-
 export const shortenNFTTokenID = (nftTokenID = '') =>
   nftTokenID.length > 20
     ? `${nftTokenID.slice(0, 10)}...${nftTokenID.slice(-10)}`