diff --git a/README.md b/README.md
index 2f5411f..1e1592a 100644
--- a/README.md
+++ b/README.md
@@ -198,7 +198,9 @@ Returns the latest Solana slot for which swap data is available.
 
 #### GET `/dexscreener/asset?id=:mintAddress`
 
-Returns token metadata for a given Solana mint address. Fetched from on-chain Metaplex Token Metadata.
+Returns token metadata and supply for a given Solana mint address. Supply is
+calculated from one confirmed mint/allocation snapshot. If supply cannot be
+verified, the endpoint returns `503` with code `SUPPLY_UNAVAILABLE`.
 
 **Response:**
 ```json
@@ -207,6 +209,8 @@ Returns token metadata for a given Solana mint address. Fetched from on-chain Me
     "id": "ZKFHiLAfAFMTcDAuCtjNW54VzpERvoe7PBF9mYgmeta",
     "name": "ZKFG",
     "symbol": "ZKFG",
+    "totalSupply": 1000000,
+    "circulatingSupply": 875000,
     "metadata": {
       "decimals": "6"
     }
@@ -294,7 +298,15 @@ Returns total supply only (plain text number).
 
 #### GET `/api/supply/:mintAddress/circulating`
 
-Returns circulating supply — total minus team performance package.
+Returns circulating supply — total minus non-circulating allocations: the team
+performance package, the additional-token allocation, DAO treasury holdings, and any
+operator-configured **excluded holders** (external/vesting/encumbered wallets listed
+in `EXCLUDED_CIRCULATING_WALLETS`). Each excluded holder's on-chain balance is read
+with the other live non-circulating balances at one confirmed slot, cached for
+`CACHE_TICKERS_TTL` (55 seconds by default), subtracted, and echoed back under
+`allocation.excludedHolders`. The shared slot is returned as
+`allocation.balanceSnapshotSlot`. This excludes direct SPL token balances only; it
+does not decode fractional ownership of DAMM pool positions.
 
 ---
 
@@ -364,6 +376,7 @@ Create a `.env` file in the root directory (see `example.env` for reference):
 | **Protocol** | | |
 | `PROTOCOL_FEE_RATE` | Protocol fee rate | `0.005` (0.5%) |
 | `EXCLUDED_DAOS` | Comma-separated DAO addresses to exclude | — |
+| `EXCLUDED_CIRCULATING_WALLETS` | Non-circulating direct SPL token holders, comma-separated `mint:wallet` or `mint:wallet:label` (external/vesting/encumbered); each wallet's live balance of that mint is subtracted from circulating supply. DAMM pool-position ownership is not decoded. | — |
 | `CMC_ALLOWED_MINTS` | Comma-separated base-mint allowlist for the `/cmc/*` routes; empty serves all. Validated at startup; if set but matching zero discovered DAOs, the CMC routes fail closed with 503. | — |
 | **Alerts** | | |
 | `ALERT_WEBHOOK_URL` | Telegram alert webhook URL | — |
diff --git a/example.env b/example.env
index ac30cdf..7f5b508 100644
--- a/example.env
+++ b/example.env
@@ -50,6 +50,14 @@ SOLANA_RPC_URL=https://api.mainnet-beta.solana.com
 # DEX_FORK_TYPE=Custom
 # FACTORY_ADDRESS=
 # ROUTER_ADDRESS=
+# Wallets whose live balance of a given mint is NON-circulating (external/vesting/
+# encumbered/protocol-owned holdings — e.g. Laso's external wallet). Subtracted from
+# that mint's circulating supply on /api/supply/:mint/circulating.
+# Direct SPL token accounts only; fractional DAMM pool-position ownership is not decoded.
+# Comma-separated entries, each `<mint>:<wallet>` or `<mint>:<wallet>:<label>`.
+# Scoped per-mint so only the vetted (mint, wallet) balance is excluded. Default: none.
+# EXCLUDED_CIRCULATING_WALLETS=<mint>:<wallet>:vesting
+
 # Allowlist of base mints exposed on the CoinMarketCap routes (/cmc/*),
 # comma-separated. Empty (default) serves every discovered DAO, same as the
 # CoinGecko/DexScreener adapters.
diff --git a/src/config.ts b/src/config.ts
index 7814260..da1629d 100644
--- a/src/config.ts
+++ b/src/config.ts
@@ -1,4 +1,76 @@
 import { PublicKey } from '@solana/web3.js';
+
+/**
+ * A wallet whose live on-chain balance of a specific mint is treated as
+ * non-circulating (external/vesting/encumbered/protocol-owned holdings that are
+ * NOT "in the hands of others"). Scoped per-mint so we only ever exclude a
+ * balance an operator has explicitly vetted as encumbered.
+ */
+export interface ExcludedHolder {
+  /** Base mint whose balance held by `wallet` is excluded from circulating supply. */
+  mint: string;
+  /** Wallet (owner) address that holds the encumbered tokens. */
+  wallet: PublicKey;
+  /** Optional human-readable tag surfaced in the supply allocation response. */
+  label?: string;
+}
+
+/**
+ * Parse the `EXCLUDED_CIRCULATING_WALLETS` env value into structured holders.
+ *
+ * Format: comma-separated entries, each `<mint>:<wallet>` or
+ * `<mint>:<wallet>:<label>`. Whitespace is trimmed and blank entries (e.g. a
+ * trailing comma) are ignored. The label may contain anything except a comma
+ * (which delimits entries).
+ *
+ * A malformed NON-blank entry (missing mint/wallet, invalid base58 pubkey)
+ * THROWS. This is a financial serving path: silently dropping a typo'd exclusion
+ * would overstate circulating supply, so we fail fast at startup instead — the
+ * same fail-loud-not-quietly-wrong contract the rest of the supply path follows.
+ */
+export function parseExcludedHolders(raw: string): ExcludedHolder[] {
+  const holders: ExcludedHolder[] = [];
+  // Dedupe by mint:wallet — a duplicated env entry (copy/paste) would otherwise be
+  // resolved and subtracted twice, double-counting the same live balance and
+  // understating circulating supply.
+  const seen = new Set<string>();
+  for (const entry of raw.split(',')) {
+    const trimmed = entry.trim();
+    if (!trimmed) continue; // blank entry / trailing comma — not an error
+    // Split into at most 3 parts so a label may itself contain ':'.
+    const firstColon = trimmed.indexOf(':');
+    const secondColon = firstColon === -1 ? -1 : trimmed.indexOf(':', firstColon + 1);
+    const mint = firstColon === -1 ? '' : trimmed.slice(0, firstColon).trim();
+    const wallet =
+      firstColon === -1
+        ? ''
+        : secondColon === -1
+          ? trimmed.slice(firstColon + 1).trim()
+          : trimmed.slice(firstColon + 1, secondColon).trim();
+    const label = secondColon === -1 ? undefined : trimmed.slice(secondColon + 1).trim() || undefined;
+    if (!mint || !wallet) {
+      throw new Error(
+        `Invalid EXCLUDED_CIRCULATING_WALLETS entry "${trimmed}" — expected "<mint>:<wallet>" or "<mint>:<wallet>:<label>"`,
+      );
+    }
+    try {
+      // Validate both are real pubkeys; keep `mint` as string (matches how the
+      // supply path compares mints) and `wallet` as a PublicKey for lookups.
+      new PublicKey(mint);
+      const walletKey = new PublicKey(wallet); // throws if invalid
+      const dedupeKey = `${mint}:${wallet}`;
+      if (seen.has(dedupeKey)) continue; // drop exact duplicate (keep first occurrence)
+      seen.add(dedupeKey);
+      holders.push({ mint, wallet: walletKey, label });
+    } catch {
+      throw new Error(
+        `Invalid EXCLUDED_CIRCULATING_WALLETS entry "${trimmed}" — mint and wallet must be valid base58 pubkeys`,
+      );
+    }
+  }
+  return holders;
+}
+
 export const config = {
   solana: {
     rpcUrl: process.env.RPCPOOL_RPC_URL || process.env.SOLANA_RPC_URL || 'https://api.mainnet-beta.solana.com',
@@ -51,6 +123,12 @@ export const config = {
     // Protocol fee rate (0.005 = 0.5%); used to report fee bps on DexScreener routes.
     protocolFeeRate: parseFloat(process.env.PROTOCOL_FEE_RATE || '0.005'),
   },
+  circulating: {
+    // Operator-vetted wallets whose live balance of a given mint is NON-circulating
+    // (external/vesting/encumbered/protocol-owned holdings). Subtracted from the
+    // circulating supply of the matching mint. See parseExcludedHolders for format.
+    excludedHolders: parseExcludedHolders(process.env.EXCLUDED_CIRCULATING_WALLETS || ''),
+  },
   coinmarketcap: {
     // Optional allowlist of base-mint addresses exposed on the CoinMarketCap
     // routes. Empty (the default) means "serve every discovered DAO", matching
diff --git a/src/routes/dexscreener.ts b/src/routes/dexscreener.ts
index 581cd29..b5067bb 100644
--- a/src/routes/dexscreener.ts
+++ b/src/routes/dexscreener.ts
@@ -1,6 +1,6 @@
 import { Router, type Request, type Response } from 'express';
 import { PublicKey } from '@solana/web3.js';
-import { asyncHandler } from '../middleware/errorHandler.js';
+import { AppError, asyncHandler } from '../middleware/errorHandler.js';
 import { logger } from '../utils/logger.js';
 import { config } from '../config.js';
 import type { ServiceGetters } from './types.js';
@@ -28,7 +28,8 @@ export function createDexScreenerRouter(services: ServiceGetters): Router {
   // valid pubkeys would grow these maps (and burn RPC per miss) without limit.
   const assetCache = new Map<string, { data: DexScreenerAssetResponse; expiresAt: number }>();
   const pairCache = new Map<string, { data: DexScreenerPairResponse; expiresAt: number }>();
-  const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+  const ASSET_CACHE_TTL_MS = config.cache.tickersTTL;
+  const PAIR_CACHE_TTL_MS = 5 * 60 * 1000;
   const CACHE_MAX_ENTRIES = 1000;
 
   function cachePut<T>(cache: Map<string, T>, key: string, value: T): void {
@@ -97,47 +98,54 @@ export function createDexScreenerRouter(services: ServiceGetters): Router {
       return res.status(400).json({ error: 'Invalid asset id (not a valid Solana address)' });
     }
 
-    const [metadata, decimals] = await Promise.all([
-      futarchyService.getTokenMetadata(mintPubkey),
-      futarchyService.getTokenDecimals(mintPubkey),
-    ]);
-
-    let totalSupply: number | undefined;
-    let circulatingSupply: number | undefined;
+    let totalSupply: number;
+    let circulatingSupply: number;
     try {
       const { supplyInfo } = await getSupplyInfoWithLaunchpadAllocation(
         id,
         solanaService,
         launchpadService,
       );
-      const total = parseFloat(supplyInfo.totalSupply);
-      const circ = parseFloat(supplyInfo.circulatingSupply);
-      if (Number.isFinite(total) && Number.isFinite(circ)) {
-        totalSupply = total;
-        circulatingSupply = circ;
+      const total = Number(supplyInfo.totalSupply);
+      const circ = Number(supplyInfo.circulatingSupply);
+      if (!Number.isFinite(total) || !Number.isFinite(circ)) {
+        throw new Error('Supply response was not a finite number');
       }
+      totalSupply = total;
+      circulatingSupply = circ;
     } catch (err) {
       logger.warn('[DexScreener] /asset could not load supply', {
         mint: id,
         error: err instanceof Error ? err.message : String(err),
       });
+      throw AppError.serviceUnavailable(
+        'Supply data temporarily unavailable',
+        'SUPPLY_UNAVAILABLE',
+      );
     }
 
+    const [metadata, decimals] = await Promise.all([
+      futarchyService.getTokenMetadata(mintPubkey),
+      futarchyService.getTokenDecimals(mintPubkey),
+    ]);
+
     const response: DexScreenerAssetResponse = {
       asset: {
         id,
         name: metadata?.name || id.slice(0, 8),
         symbol: metadata?.symbol || id.slice(0, 8),
-        ...(totalSupply !== undefined && circulatingSupply !== undefined
-          ? { totalSupply, circulatingSupply }
-          : {}),
+        totalSupply,
+        circulatingSupply,
         metadata: {
           decimals: String(decimals),
         },
       },
     };
 
-    cachePut(assetCache, id, { data: response, expiresAt: Date.now() + CACHE_TTL_MS });
+    cachePut(assetCache, id, {
+      data: response,
+      expiresAt: Date.now() + ASSET_CACHE_TTL_MS,
+    });
     res.json(response);
   }));
 
@@ -196,7 +204,10 @@ export function createDexScreenerRouter(services: ServiceGetters): Router {
       },
     };
 
-    cachePut(pairCache, id, { data: response, expiresAt: Date.now() + CACHE_TTL_MS });
+    cachePut(pairCache, id, {
+      data: response,
+      expiresAt: Date.now() + PAIR_CACHE_TTL_MS,
+    });
     res.json(response);
   }));
 
diff --git a/src/routes/root.ts b/src/routes/root.ts
index bef2f32..bcd4940 100644
--- a/src/routes/root.ts
+++ b/src/routes/root.ts
@@ -16,7 +16,7 @@ export function createRootRouter(_services: ServiceGetters): Router {
         market_data: '/api/market-data - Daily market data from the served user_pool ETL',
         supply: '/api/supply/:mintAddress - Returns complete supply breakdown with allocation details',
         supply_total: '/api/supply/:mintAddress/total - Returns total supply only',
-        supply_circulating: '/api/supply/:mintAddress/circulating - Returns circulating supply (excludes team performance package)',
+        supply_circulating: '/api/supply/:mintAddress/circulating - Returns circulating supply after configured non-circulating allocations',
         health: '/health',
         health_detailed: '/api/health - Comprehensive health with app DB and served ETL contract checks',
       },
@@ -40,10 +40,11 @@ export function createRootRouter(_services: ServiceGetters): Router {
       },
       supplyBreakdown: {
         description: 'For launchpad tokens, supply is broken down into:',
-        circulatingSupply: 'Total supply minus team performance package (liquidity IS circulating)',
+        circulatingSupply: 'Total supply minus non-circulating allocations: team package, additional token allocation, DAO treasury tokens, and configured excluded holders',
         teamPerformancePackage: 'Locked tokens allocated to the team (price-based unlock) - NOT circulating',
-        futarchyAmmLiquidity: 'Tokens in the internal FutarchyAMM for spot trading - IS circulating',
-        meteoraLpLiquidity: 'Tokens in the external Meteora DAMM pool (POL) - IS circulating',
+        futarchyAmmLiquidity: 'Tokens in the internal FutarchyAMM for spot trading - reported for transparency and treated as circulating',
+        meteoraLpLiquidity: 'Tokens in the external Meteora DAMM pool (POL) - reported for transparency and treated as circulating',
+        excludedHolders: 'Operator-configured direct SPL token holder balances excluded from circulating supply; fractional DAMM position ownership is not decoded here',
       },
       note: 'Read-only API. Market data and ticker volume are served from the user_pool ETL in the served DB; no Dune, no in-process indexing.',
     });
diff --git a/src/routes/supply.ts b/src/routes/supply.ts
index 81938cd..7a4e264 100644
--- a/src/routes/supply.ts
+++ b/src/routes/supply.ts
@@ -5,6 +5,14 @@ import { asyncHandler, AppError } from '../middleware/errorHandler.js';
 import { logger } from '../utils/logger.js';
 import { getSupplyInfoWithLaunchpadAllocation } from '../services/supplyWithLaunchpadAllocation.js';
 
+function parseFiniteSupply(value: string): number {
+  const supply = Number(value);
+  if (!Number.isFinite(supply)) {
+    throw new Error('Supply response was not a finite number');
+  }
+  return supply;
+}
+
 export function createSupplyRouter(services: ServiceGetters): Router {
   const router = Router();
   const { getSolanaService, getLaunchpadService } = services;
@@ -17,19 +25,19 @@ export function createSupplyRouter(services: ServiceGetters): Router {
       throw AppError.badRequest(mintAddressResult.error.message, 'INVALID_MINT_ADDRESS');
     }
     const mintAddress = mintAddressResult.value;
-      const solanaService = getSolanaService();
-      const launchpadService = getLaunchpadService();
-
-      const { supplyInfo } = await getSupplyInfoWithLaunchpadAllocation(
-        mintAddress,
-        solanaService,
-        launchpadService,
-      );
-
-      res.json({
-        result: supplyInfo.totalSupply,
-        data: supplyInfo,
-      });
+    const solanaService = getSolanaService();
+    const launchpadService = getLaunchpadService();
+
+    const { supplyInfo } = await getSupplyInfoWithLaunchpadAllocation(
+      mintAddress,
+      solanaService,
+      launchpadService,
+    );
+
+    res.json({
+      result: supplyInfo.totalSupply,
+      data: supplyInfo,
+    });
   }));
 
   // Get total supply for a token
@@ -64,8 +72,8 @@ export function createSupplyRouter(services: ServiceGetters): Router {
       launchpadService,
     );
 
-    const response: { 
-      result: string; 
+    const response: {
+      result: string;
       allocation?: {
         teamPerformancePackageAddress?: string;
         futarchyAmmVaultAddress?: string;
@@ -84,6 +92,12 @@ export function createSupplyRouter(services: ServiceGetters): Router {
           amount: string;
           vaultAddress?: string;
         };
+        excludedHolders?: Array<{
+          amount: string;
+          address: string;
+          label?: string;
+        }>;
+        balanceSnapshotSlot?: number;
         daoAddress?: string;
         launchAddress?: string;
         version?: string;
@@ -92,11 +106,12 @@ export function createSupplyRouter(services: ServiceGetters): Router {
       result: supplyInfo.circulatingSupply,
     };
     
-    if (allocation.teamPerformancePackage.address || 
-        allocation.futarchyAmmLiquidity.vaultAddress || 
+    if (allocation.teamPerformancePackage.address ||
+        allocation.futarchyAmmLiquidity.vaultAddress ||
         allocation.meteoraLpLiquidity.poolAddress ||
         allocation.additionalTokenAllocation ||
-        !allocation.daoTreasuryTokens.amount.isZero()) {
+        !allocation.daoTreasuryTokens.amount.isZero() ||
+        (allocation.excludedHolders?.length ?? 0) > 0) {
       response.allocation = {
         teamPerformancePackageAddress: allocation.teamPerformancePackage.address?.toString(),
         futarchyAmmVaultAddress: allocation.futarchyAmmLiquidity.vaultAddress?.toString(),
@@ -105,6 +120,8 @@ export function createSupplyRouter(services: ServiceGetters): Router {
         additionalTokenAllocation: supplyInfo.allocation?.additionalTokenAllocation,
         initialTokenAllocation: supplyInfo.allocation?.initialTokenAllocation,
         daoTreasuryTokens: supplyInfo.allocation?.daoTreasuryTokens,
+        excludedHolders: supplyInfo.allocation?.excludedHolders,
+        balanceSnapshotSlot: supplyInfo.allocation?.balanceSnapshotSlot,
         daoAddress: allocation.daoAddress?.toString(),
         launchAddress: allocation.launchAddress?.toString(),
         version: allocation.version,
@@ -131,7 +148,7 @@ export function createSupplyRouter(services: ServiceGetters): Router {
       launchpadService,
     );
 
-    res.json({ circulatingSupply: parseFloat(supplyInfo.circulatingSupply) });
+    res.json({ circulatingSupply: parseFiniteSupply(supplyInfo.circulatingSupply) });
   }));
 
   // Jupiter-compatible total supply
@@ -144,7 +161,7 @@ export function createSupplyRouter(services: ServiceGetters): Router {
     const solanaService = getSolanaService();
     const supplyInfo = await solanaService.getSupplyInfo(mintAddressResult.value);
 
-    res.json({ totalSupply: parseFloat(supplyInfo.totalSupply) });
+    res.json({ totalSupply: parseFiniteSupply(supplyInfo.totalSupply) });
   }));
 
   return router;
diff --git a/src/services/launchpadService.ts b/src/services/launchpadService.ts
index 8b297dd..cc65811 100644
--- a/src/services/launchpadService.ts
+++ b/src/services/launchpadService.ts
@@ -1,4 +1,8 @@
-import { Connection, PublicKey, Keypair } from '@solana/web3.js';
+import {
+  Connection,
+  PublicKey,
+  Keypair,
+} from '@solana/web3.js';
 import { AnchorProvider, Wallet } from '@coral-xyz/anchor';
 import {
   LaunchpadClient as LaunchpadClientV06,
@@ -15,7 +19,14 @@ import {
   LAUNCHPAD_V0_6_MAINNET_METEORA_CONFIG as MAINNET_METEORA_CONFIG_V06,
   LAUNCHPAD_V0_7_MAINNET_METEORA_CONFIG as MAINNET_METEORA_CONFIG_V07,
 } from "@metadaoproject/programs";
-import { getAccount, getAssociatedTokenAddress } from '@solana/spl-token';
+import {
+  getAccount,
+  getAssociatedTokenAddress,
+  TOKEN_2022_PROGRAM_ID,
+  TOKEN_PROGRAM_ID,
+  unpackAccount,
+  unpackMint,
+} from '@solana/spl-token';
 import { isTokenAccountAbsent } from '../utils/solanaErrors.js';
 import { config } from '../config.js';
 import BN from 'bn.js';
@@ -34,6 +45,17 @@ export interface AdditionalTokenAllocation {
   tokenAccountAddress?: PublicKey;
 }
 
+/**
+ * A configured non-circulating holder resolved to its live on-chain balance.
+ * These are operator-vetted external/vesting/encumbered/protocol-owned wallets
+ * (e.g. Laso's external wallet) whose tokens are NOT "in the hands of others".
+ */
+export interface ExcludedHolderBalance {
+  wallet: PublicKey;
+  label?: string;
+  amount: BN;
+}
+
 /**
  * Complete token allocation breakdown for launchpad tokens
  */
@@ -63,11 +85,22 @@ export interface TokenAllocationBreakdown {
     amount: BN;
     vaultAddress?: PublicKey;
   };
+  // Operator-configured non-circulating holders (external/vesting/encumbered) for
+  // this mint, resolved to their live on-chain balances. Empty when none configured.
+  excludedHolders: ExcludedHolderBalance[];
+  // Confirmed Solana slot for the single mint-supply and live-balance RPC batch.
+  balanceSnapshotSlot?: number;
+  // Mint supply read in the same RPC snapshot as the live balances.
+  mintSupplySnapshot: {
+    amount: BN;
+    decimals: number;
+  };
   // DAO address (if launch completed)
   daoAddress?: PublicKey;
   // Launch address
   launchAddress?: PublicKey;
-  // Total non-circulating supply (performance package + additional tokens if unclaimed + DAO treasury)
+  // Total non-circulating supply (performance package + additional tokens if unclaimed
+  // + DAO treasury + configured excluded holders)
   totalNonCirculating: BN;
 }
 
@@ -93,6 +126,9 @@ export type LaunchState =
   | { cancelled: Record<string, never> };
 
 export class LaunchpadService {
+  private static readonly CACHE_MAX_ENTRIES = 1000;
+  private static readonly MAX_SNAPSHOT_ACCOUNTS = 100;
+
   private connection: Connection;
   private clientV06: LaunchpadClientV06;
   private clientV07: LaunchpadClientV07;
@@ -130,6 +166,15 @@ export class LaunchpadService {
   }
 
   private setCache(key: string, data: any): void {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    }
+    if (this.cache.size >= LaunchpadService.CACHE_MAX_ENTRIES) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey !== undefined) {
+        this.cache.delete(oldestKey);
+      }
+    }
     this.cache.set(key, { data, timestamp: Date.now() });
   }
 
@@ -184,7 +229,9 @@ export class LaunchpadService {
    */
   async getLaunchByBaseMint(baseMint: PublicKey): Promise<LaunchData | null> {
     const cacheKey = `launch_by_mint_${baseMint.toString()}`;
-    const cached = this.getCached<LaunchData>(cacheKey, config.cache.tickersTTL * 10);
+    // Claim state changes circulating supply, so launch data must not outlive the
+    // allocation/supply cache cadence.
+    const cached = this.getCached<LaunchData>(cacheKey, config.cache.tickersTTL);
     if (cached) return cached;
 
     const launchAddressV07 = this.getLaunchAddressV07(baseMint);
@@ -391,6 +438,211 @@ export class LaunchpadService {
     }
   }
 
+  /**
+   * Discover every configured holder's token accounts, then read the mint and all
+   * relevant token accounts in one contextual getMultipleAccounts call. Account
+   * discovery is repeated after the snapshot; if the address set changed around
+   * the snapshot, the whole operation is retried.
+   */
+  private async getLiveBalanceSnapshot(
+    baseMint: PublicKey,
+    performancePackageOwner?: PublicKey,
+    daoTreasuryOwner?: PublicKey,
+  ): Promise<{
+    excludedHolders: ExcludedHolderBalance[];
+    performancePackageAmount: BN;
+    daoTreasuryAmount: BN;
+    mintSupply: {
+      amount: BN;
+      decimals: number;
+    };
+    tokenProgramId: PublicKey;
+    slot: number;
+  }> {
+    const mint = baseMint.toString();
+    const configured = config.circulating.excludedHolders.filter(h => h.mint === mint);
+    const maxAttempts = 3;
+
+    const deriveCandidateAtas = async (owner: PublicKey | undefined) => {
+      if (!owner) return undefined;
+      const [legacy, token2022] = await Promise.all([
+        getAssociatedTokenAddress(baseMint, owner, true, TOKEN_PROGRAM_ID),
+        getAssociatedTokenAddress(baseMint, owner, true, TOKEN_2022_PROGRAM_ID),
+      ]);
+      return { legacy, token2022 };
+    };
+    const [performancePackageAtas, daoTreasuryAtas] = await Promise.all([
+      deriveCandidateAtas(performancePackageOwner),
+      deriveCandidateAtas(daoTreasuryOwner),
+    ]);
+
+    const discoverHolderAccounts = async (minContextSlot?: number) =>
+      Promise.all(
+        configured.map(holder =>
+          this.connection.getTokenAccountsByOwner(
+            holder.wallet,
+            { mint: baseMint },
+            {
+              commitment: 'confirmed',
+              ...(minContextSlot !== undefined ? { minContextSlot } : {}),
+            },
+          ),
+        ),
+      );
+
+    const accountAddresses = (
+      responses: Awaited<ReturnType<typeof discoverHolderAccounts>>,
+    ): string[][] =>
+      responses.map(response =>
+        response.value
+          .map(({ pubkey }) => pubkey.toString())
+          .sort(),
+      );
+
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      const firstDiscovery = await discoverHolderAccounts();
+      const minimumSnapshotSlot = firstDiscovery.reduce(
+        (maximum, response) => Math.max(maximum, response.context.slot),
+        0,
+      );
+
+      const uniqueAddresses = new Map<string, PublicKey>();
+      const addAddress = (address: PublicKey | undefined): void => {
+        if (address) uniqueAddresses.set(address.toString(), address);
+      };
+      addAddress(baseMint);
+      for (const response of firstDiscovery) {
+        for (const { pubkey } of response.value) addAddress(pubkey);
+      }
+      addAddress(performancePackageAtas?.legacy);
+      addAddress(performancePackageAtas?.token2022);
+      addAddress(daoTreasuryAtas?.legacy);
+      addAddress(daoTreasuryAtas?.token2022);
+
+      if (uniqueAddresses.size > LaunchpadService.MAX_SNAPSHOT_ACCOUNTS) {
+        throw new Error(
+          `[Launchpad] Non-circulating snapshot for ${mint} requires ${uniqueAddresses.size} accounts; maximum is ${LaunchpadService.MAX_SNAPSHOT_ACCOUNTS}`,
+        );
+      }
+
+      const addresses = [...uniqueAddresses.values()];
+      const snapshot = await this.connection.getMultipleAccountsInfoAndContext(
+        addresses,
+        {
+          commitment: 'confirmed',
+          ...(minimumSnapshotSlot > 0 ? { minContextSlot: minimumSnapshotSlot } : {}),
+        },
+      );
+      const secondDiscovery = await discoverHolderAccounts(snapshot.context.slot);
+
+      const firstAddresses = accountAddresses(firstDiscovery);
+      const secondAddresses = accountAddresses(secondDiscovery);
+      if (JSON.stringify(firstAddresses) !== JSON.stringify(secondAddresses)) {
+        logger.warn('[Launchpad] Retrying after token-account topology changed around snapshot', {
+          mint,
+          attempt,
+          snapshotSlot: snapshot.context.slot,
+        });
+        if (attempt < maxAttempts) continue;
+        throw new Error(
+          `[Launchpad] Token-account topology changed around ${mint} snapshot for ${maxAttempts} attempts`,
+        );
+      }
+
+      const accountsByAddress = new Map(
+        addresses.map((address, index) => [
+          address.toString(),
+          snapshot.value[index] ?? null,
+        ]),
+      );
+      const mintAccount = accountsByAddress.get(mint);
+      if (!mintAccount) {
+        throw new Error(`[Launchpad] Mint account ${mint} was absent from balance snapshot`);
+      }
+      if (
+        !mintAccount.owner.equals(TOKEN_PROGRAM_ID) &&
+        !mintAccount.owner.equals(TOKEN_2022_PROGRAM_ID)
+      ) {
+        throw new Error(`[Launchpad] Mint ${mint} is not owned by a supported token program`);
+      }
+      const tokenProgramId = mintAccount.owner;
+      const mintInfo = unpackMint(baseMint, mintAccount, tokenProgramId);
+      const selectAta = (
+        candidates: { legacy: PublicKey; token2022: PublicKey } | undefined,
+      ): PublicKey | undefined =>
+        tokenProgramId.equals(TOKEN_2022_PROGRAM_ID)
+          ? candidates?.token2022
+          : candidates?.legacy;
+      const performancePackageAta = selectAta(performancePackageAtas);
+      const daoTreasuryAta = selectAta(daoTreasuryAtas);
+
+      const readTokenAmount = (
+        address: PublicKey | undefined,
+        description: string,
+        absentIsZero: boolean,
+      ): BN => {
+        if (!address) return new BN(0);
+        const accountInfo = accountsByAddress.get(address.toString());
+        if (!accountInfo) {
+          if (absentIsZero) return new BN(0);
+          throw new Error(`[Launchpad] ${description} was absent from balance snapshot`);
+        }
+        const tokenAccount = unpackAccount(address, accountInfo, tokenProgramId);
+        if (!tokenAccount.mint.equals(baseMint)) {
+          throw new Error(`[Launchpad] ${description} belongs to an unexpected mint`);
+        }
+        return new BN(tokenAccount.amount.toString());
+      };
+
+      const excludedHolders = configured.map((holder, index) => {
+        const addressesForHolder = firstDiscovery[index]!.value.map(({ pubkey }) => pubkey);
+        const amount = addressesForHolder.reduce(
+          (sum, address) =>
+            sum.add(readTokenAmount(
+              address,
+              `excluded holder account ${address.toString()}`,
+              false,
+            )),
+          new BN(0),
+        );
+        logger.info(
+          `[Launchpad] Excluded holder ${holder.wallet.toString()} (${holder.label ?? 'unlabeled'}) holds ${amount.toString()} tokens of ${mint} across ${addressesForHolder.length} account(s)`,
+        );
+        return { wallet: holder.wallet, label: holder.label, amount };
+      });
+
+      return {
+        excludedHolders,
+        performancePackageAmount: readTokenAmount(
+          performancePackageAta,
+          `performance package ATA ${performancePackageAta?.toString()}`,
+          true,
+        ),
+        daoTreasuryAmount: readTokenAmount(
+          daoTreasuryAta,
+          `DAO treasury ATA ${daoTreasuryAta?.toString()}`,
+          true,
+        ),
+        mintSupply: {
+          amount: new BN(mintInfo.supply.toString()),
+          decimals: mintInfo.decimals,
+        },
+        tokenProgramId,
+        slot: snapshot.context.slot,
+      };
+    }
+
+    throw new Error(`[Launchpad] Unreachable balance snapshot state for ${mint}`);
+  }
+
+  private async getExcludedHolderBalances(baseMint: PublicKey): Promise<ExcludedHolderBalance[]> {
+    if (!config.circulating.excludedHolders.some(holder => holder.mint === baseMint.toString())) {
+      return [];
+    }
+    const snapshot = await this.getLiveBalanceSnapshot(baseMint);
+    return snapshot.excludedHolders;
+  }
+
   /**
    * Get the complete token allocation breakdown for a launchpad token.
    * This provides a complete picture of where all tokens are allocated:
@@ -398,23 +650,16 @@ export class LaunchpadService {
    * - FutarchyAMM Liquidity (internal AMM)
    * - Meteora LP Liquidity (external DEX)
    * - Additional Token Allocation (v0.7+ only, not in circulating supply until claimed)
-   * 
-   * Circulating Supply = Total - Team - FutarchyAMM - Meteora - AdditionalTokens (if unclaimed)
+   *
+   * FutarchyAMM and Meteora liquidity remain circulating. Mint supply and live
+   * non-circulating balances are read in one confirmed contextual RPC batch and
+   * cached for the normal ticker TTL.
    */
   async getTokenAllocationBreakdown(baseMint: PublicKey): Promise<TokenAllocationBreakdown> {
     const cacheKey = `allocation_${baseMint.toString()}`;
-    const cached = this.getCached<TokenAllocationBreakdown>(cacheKey, config.cache.tickersTTL * 5);
+    const cached = this.getCached<TokenAllocationBreakdown>(cacheKey, config.cache.tickersTTL);
     if (cached) return cached;
 
-    const emptyBreakdown: TokenAllocationBreakdown = {
-      version: 'v0.6',
-      teamPerformancePackage: { amount: new BN(0) },
-      futarchyAmmLiquidity: { amount: new BN(0) },
-      meteoraLpLiquidity: { amount: new BN(0) },
-      daoTreasuryTokens: { amount: new BN(0) },
-      totalNonCirculating: new BN(0),
-    };
-
     // No catch-all below: an empty breakdown is returned ONLY for the two
     // genuinely-empty cases (token never launched / launch not completed).
     // Every infrastructure failure (RPC, network, timeout) propagates to the
@@ -423,17 +668,46 @@ export class LaunchpadService {
     // the exact mispricing the isTokenAccountAbsent contract exists to prevent.
     const launch = await this.getLaunchByBaseMint(baseMint);
     if (!launch) {
-      // Token was not launched via launchpad
-      return emptyBreakdown;
+      const snapshot = await this.getLiveBalanceSnapshot(baseMint);
+      const excludedHoldersTotal = snapshot.excludedHolders.reduce(
+        (sum, holder) => sum.add(holder.amount),
+        new BN(0),
+      );
+      const breakdown: TokenAllocationBreakdown = {
+        version: 'v0.6',
+        teamPerformancePackage: { amount: new BN(0) },
+        futarchyAmmLiquidity: { amount: new BN(0) },
+        meteoraLpLiquidity: { amount: new BN(0) },
+        daoTreasuryTokens: { amount: new BN(0) },
+        excludedHolders: snapshot.excludedHolders,
+        balanceSnapshotSlot: snapshot.slot,
+        mintSupplySnapshot: snapshot.mintSupply,
+        totalNonCirculating: excludedHoldersTotal,
+      };
+      this.setCache(cacheKey, breakdown);
+      return breakdown;
     }
 
     if (!launch.dao) {
-      // Launch not yet completed
-      return {
-        ...emptyBreakdown,
+      const snapshot = await this.getLiveBalanceSnapshot(baseMint);
+      const excludedHoldersTotal = snapshot.excludedHolders.reduce(
+        (sum, holder) => sum.add(holder.amount),
+        new BN(0),
+      );
+      const breakdown: TokenAllocationBreakdown = {
         version: launch.version,
+        teamPerformancePackage: { amount: new BN(0) },
+        futarchyAmmLiquidity: { amount: new BN(0) },
+        meteoraLpLiquidity: { amount: new BN(0) },
+        daoTreasuryTokens: { amount: new BN(0) },
+        excludedHolders: snapshot.excludedHolders,
+        balanceSnapshotSlot: snapshot.slot,
+        mintSupplySnapshot: snapshot.mintSupply,
         launchAddress: launch.launchAddress,
+        totalNonCirculating: excludedHoldersTotal,
       };
+      this.setCache(cacheKey, breakdown);
+      return breakdown;
     }
 
     // Get DAO to find quote mint
@@ -445,29 +719,9 @@ export class LaunchpadService {
     // tokens may have been unlocked/claimed (e.g. ZKFG, Loyal), making the configured
     // amount stale and over-subtracting from circulating supply.
     const performancePackageAddress = this.getPerformancePackageAddress(
-      launch.launchAddress, 
-      launch.version
+      launch.launchAddress,
+      launch.version,
     );
-
-    let performancePackageLockedAmount = new BN(0);
-    try {
-      const ppAta = await getAssociatedTokenAddress(
-        baseMint,
-        performancePackageAddress,
-        true
-      );
-      const ppTokenAccount = await getAccount(this.connection, ppAta);
-      performancePackageLockedAmount = new BN(ppTokenAccount.amount.toString());
-      logger.info(`[Launchpad] Performance package at ${performancePackageAddress.toString()} holds ${performancePackageLockedAmount.toString()} tokens (configured: ${launch.performancePackageTokenAmount.toString()})`);
-    } catch (error: any) {
-      // Account genuinely absent → all tokens unlocked/claimed → 0 locked (correct).
-      // An RPC failure must propagate: treating it as 0 locked would OVERSTATE
-      // circulating supply (the live-balance approach exists precisely to avoid
-      // mis-subtracting — so a silent 0 on outage is the exact failure to avoid).
-      if (!isTokenAccountAbsent(error)) throw error;
-      logger.info(`[Launchpad] Performance package token account not found for ${performancePackageAddress.toString()}, 0 locked`);
-    }
-
     // Get FutarchyAMM liquidity
     const futarchyAmm = await this.getFutarchyAmmLiquidity(launch.dao);
 
@@ -481,43 +735,50 @@ export class LaunchpadService {
     // Handle additional token allocation (v0.7+ only)
     let additionalTokenAllocation: AdditionalTokenAllocation | undefined;
     if (launch.version === 'v0.7' && launch.additionalTokensRecipient && launch.additionalTokensAmount) {
-      // Get the token account address for the additional tokens recipient
-      let tokenAccountAddress: PublicKey | undefined;
-      try {
-        tokenAccountAddress = await getAssociatedTokenAddress(
-          baseMint,
-          launch.additionalTokensRecipient
-        );
-      } catch (error) {
-        logger.warn(`[Launchpad] Could not derive additional tokens account for ${launch.additionalTokensRecipient.toString()}`);
-      }
-
       additionalTokenAllocation = {
         recipient: launch.additionalTokensRecipient,
         amount: launch.additionalTokensAmount,
         claimed: launch.additionalTokensClaimed || false,
-        tokenAccountAddress,
       };
     }
 
-    // Get DAO treasury base token balance (tokens held by the squads vault)
-    let daoTreasuryTokens: { amount: BN; vaultAddress?: PublicKey } = { amount: new BN(0) };
+    // Resolve the DAO treasury owner and ATA before taking the shared live-balance snapshot.
+    let daoTreasuryVaultAddress: PublicKey | undefined;
     if (dao && (dao as any).squadsMultisigVault) {
-      try {
-        const vaultAddress = new PublicKey((dao as any).squadsMultisigVault);
-        const vaultAta = await getAssociatedTokenAddress(baseMint, vaultAddress, true);
-        const tokenAccount = await getAccount(this.connection, vaultAta);
-        daoTreasuryTokens = {
-          amount: new BN(tokenAccount.amount.toString()),
-          vaultAddress,
-        };
-        logger.info(`[Launchpad] DAO treasury holds ${daoTreasuryTokens.amount.toString()} base tokens in vault ${vaultAddress.toString()}`);
-      } catch (error: any) {
-        // Genuinely-absent treasury ATA → 0 treasury tokens (correct). An RPC
-        // failure must propagate (a silent 0 here overstates circulating supply).
-        if (!isTokenAccountAbsent(error)) throw error;
-        logger.info(`[Launchpad] No base token account in DAO treasury vault`);
-      }
+      daoTreasuryVaultAddress = new PublicKey((dao as any).squadsMultisigVault);
+    }
+
+    const snapshot = await this.getLiveBalanceSnapshot(
+      baseMint,
+      performancePackageAddress,
+      daoTreasuryVaultAddress,
+    );
+    if (additionalTokenAllocation) {
+      additionalTokenAllocation.tokenAccountAddress = await getAssociatedTokenAddress(
+        baseMint,
+        additionalTokenAllocation.recipient,
+        true,
+        snapshot.tokenProgramId,
+      );
+    }
+    const performancePackageLockedAmount = snapshot.performancePackageAmount;
+    const excludedHolders = snapshot.excludedHolders;
+    const excludedHoldersTotal = excludedHolders.reduce(
+      (sum, holder) => sum.add(holder.amount),
+      new BN(0),
+    );
+    const daoTreasuryTokens: { amount: BN; vaultAddress?: PublicKey } = {
+      amount: snapshot.daoTreasuryAmount,
+      vaultAddress: daoTreasuryVaultAddress,
+    };
+
+    logger.info(
+      `[Launchpad] Performance package at ${performancePackageAddress.toString()} holds ${performancePackageLockedAmount.toString()} tokens (configured: ${launch.performancePackageTokenAmount.toString()})`,
+    );
+    if (daoTreasuryVaultAddress) {
+      logger.info(
+        `[Launchpad] DAO treasury holds ${daoTreasuryTokens.amount.toString()} base tokens in vault ${daoTreasuryVaultAddress.toString()}`,
+      );
     }
 
     // Calculate total non-circulating supply using live on-chain balance
@@ -531,6 +792,9 @@ export class LaunchpadService {
     // Add DAO treasury tokens (protocol-controlled, not circulating)
     totalNonCirculating = totalNonCirculating.add(daoTreasuryTokens.amount);
 
+    // Add configured excluded holders (external/vesting/encumbered, not circulating)
+    totalNonCirculating = totalNonCirculating.add(excludedHoldersTotal);
+
     const breakdown: TokenAllocationBreakdown = {
       version: launch.version,
       teamPerformancePackage: {
@@ -548,15 +812,17 @@ export class LaunchpadService {
       },
       additionalTokenAllocation,
       daoTreasuryTokens,
+      excludedHolders,
+      balanceSnapshotSlot: snapshot.slot,
+      mintSupplySnapshot: snapshot.mintSupply,
       daoAddress: launch.dao,
       launchAddress: launch.launchAddress,
       totalNonCirculating,
     };
 
-  this.setCache(cacheKey, breakdown);
-  return breakdown;
+    this.setCache(cacheKey, breakdown);
+    return breakdown;
   }
 }
 
 export default LaunchpadService;
-
diff --git a/src/services/solanaService.ts b/src/services/solanaService.ts
index 7ce0467..74189f0 100644
--- a/src/services/solanaService.ts
+++ b/src/services/solanaService.ts
@@ -1,5 +1,10 @@
 import { Connection, PublicKey } from '@solana/web3.js';
-import { getMint } from '@solana/spl-token';
+import {
+  TOKEN_2022_PROGRAM_ID,
+  TOKEN_PROGRAM_ID,
+  unpackMint,
+  type Mint,
+} from '@solana/spl-token';
 import { config } from '../config.js';
 import BN from 'bn.js';
 import { retry, isTransientError, createRetryLogger } from '../utils/resilience.js';
@@ -46,6 +51,14 @@ export interface TokenSupplyInfo {
       amount: string;
       vaultAddress?: string;
     };
+    // Operator-configured non-circulating holders (external/vesting/encumbered)
+    excludedHolders?: Array<{
+      amount: string;
+      address: string;
+      label?: string;
+    }>;
+    // Confirmed slot shared by live non-circulating balance reads.
+    balanceSnapshotSlot?: number;
     // DAO address
     daoAddress?: string;
     // Launch address
@@ -81,12 +94,25 @@ export interface TokenAllocationInput {
     amount: BN;
     vaultAddress?: string;
   };
+  // Operator-configured non-circulating holders (external/vesting/encumbered)
+  excludedHolders?: Array<{
+    amount: BN;
+    address: string;
+    label?: string;
+  }>;
+  balanceSnapshotSlot?: number;
+  mintSupplySnapshot?: {
+    amount: BN;
+    decimals: number;
+  };
   daoAddress?: string;
   launchAddress?: string;
   version?: string;
 }
 
 export class SolanaService {
+  private static readonly CACHE_MAX_ENTRIES = 1000;
+
   private connection: Connection;
   private cache: Map<string, { data: any; timestamp: number }>;
 
@@ -104,9 +130,68 @@ export class SolanaService {
   }
 
   private setCache(key: string, data: any): void {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    }
+    if (this.cache.size >= SolanaService.CACHE_MAX_ENTRIES) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey !== undefined) {
+        this.cache.delete(oldestKey);
+      }
+    }
     this.cache.set(key, { data, timestamp: Date.now() });
   }
 
+  private assertNonOverlappingAllocations(allocation: TokenAllocationInput): void {
+    const occupiedOwners = new Map<string, string>();
+    const addOccupiedOwner = (address: string | undefined, category: string, amount: BN): void => {
+      if (address && amount.gt(new BN(0))) {
+        const existingCategory = occupiedOwners.get(address);
+        if (existingCategory) {
+          throw new Error(
+            `Allocation owner ${address} overlaps the ${existingCategory} and ${category} allocations`,
+          );
+        }
+        occupiedOwners.set(address, category);
+      }
+    };
+
+    addOccupiedOwner(
+      allocation.teamPerformancePackage.address,
+      'team performance package',
+      allocation.teamPerformancePackage.amount,
+    );
+    addOccupiedOwner(
+      allocation.daoTreasuryTokens?.vaultAddress,
+      'DAO treasury',
+      allocation.daoTreasuryTokens?.amount ?? new BN(0),
+    );
+    if (allocation.additionalTokenAllocation && !allocation.additionalTokenAllocation.claimed) {
+      addOccupiedOwner(
+        allocation.additionalTokenAllocation.recipient,
+        'unclaimed additional-token allocation',
+        allocation.additionalTokenAllocation.amount,
+      );
+    }
+
+    const seenExcludedOwners = new Set<string>();
+    for (const holder of allocation.excludedHolders ?? []) {
+      if (seenExcludedOwners.has(holder.address)) {
+        throw new Error(
+          `Excluded holder ${holder.address} is configured more than once`,
+        );
+      }
+      seenExcludedOwners.add(holder.address);
+
+      const overlappingCategory = occupiedOwners.get(holder.address);
+      if (overlappingCategory && holder.amount.gt(new BN(0))) {
+        throw new Error(
+          `Excluded holder ${holder.address} overlaps the ${overlappingCategory} allocation`,
+        );
+      }
+    }
+  }
+
   /**
    * Retry wrapper for RPC calls with exponential backoff.
    */
@@ -120,6 +205,22 @@ export class SolanaService {
     });
   }
 
+  private async getMintInfo(mintAddress: PublicKey): Promise<Mint> {
+    const accountInfo = await this.connection.getAccountInfo(mintAddress, 'confirmed');
+    if (!accountInfo) {
+      throw new Error(`Mint account ${mintAddress.toString()} was not found`);
+    }
+    if (
+      !accountInfo.owner.equals(TOKEN_PROGRAM_ID) &&
+      !accountInfo.owner.equals(TOKEN_2022_PROGRAM_ID)
+    ) {
+      throw new Error(
+        `Mint ${mintAddress.toString()} is not owned by a supported token program`,
+      );
+    }
+    return unpackMint(mintAddress, accountInfo, accountInfo.owner);
+  }
+
   /**
    * Validate if a string is a valid Solana public key
    */
@@ -144,7 +245,7 @@ export class SolanaService {
 
     try {
       const mintPubkey = new PublicKey(mintAddress);
-      const mintInfo = await this.withRetry(() => getMint(this.connection, mintPubkey));
+      const mintInfo = await this.withRetry(() => this.getMintInfo(mintPubkey));
       const supply = Number(mintInfo.supply);
       const decimals = mintInfo.decimals;
 
@@ -166,20 +267,86 @@ export class SolanaService {
    * @returns Promise<TokenSupplyInfo> - Complete supply information with allocation details
    */
   async getSupplyInfo(mintAddress: string, allocation?: TokenAllocationInput): Promise<TokenSupplyInfo> {
-    const additionalAmount = allocation?.additionalTokenAllocation?.amount || new BN(0);
-    const daoTreasuryAmount = allocation?.daoTreasuryTokens?.amount || new BN(0);
-    const cacheKey = allocation 
-      ? `supply_info_${mintAddress}_${allocation.teamPerformancePackage.amount}_${allocation.futarchyAmmLiquidity.amount}_${allocation.meteoraLpLiquidity.amount}_${additionalAmount}_${daoTreasuryAmount}`
+    if (allocation) {
+      this.assertNonOverlappingAllocations(allocation);
+    }
+
+    const excludedHolders = allocation?.excludedHolders || [];
+    const excludedHoldersTotal = excludedHolders.reduce(
+      (sum, h) => sum.add(h.amount),
+      new BN(0),
+    );
+    // Key on every response-bearing allocation field, including the live-balance
+    // slot. Equal numeric totals from different owners must not reuse each
+    // other's allocation metadata.
+    const allocationCacheKey = allocation
+      ? JSON.stringify({
+          teamPerformancePackage: {
+            amount: allocation.teamPerformancePackage.amount.toString(),
+            address: allocation.teamPerformancePackage.address,
+          },
+          futarchyAmmLiquidity: {
+            amount: allocation.futarchyAmmLiquidity.amount.toString(),
+            vaultAddress: allocation.futarchyAmmLiquidity.vaultAddress,
+          },
+          meteoraLpLiquidity: {
+            amount: allocation.meteoraLpLiquidity.amount.toString(),
+            poolAddress: allocation.meteoraLpLiquidity.poolAddress,
+            vaultAddress: allocation.meteoraLpLiquidity.vaultAddress,
+          },
+          additionalTokenAllocation: allocation.additionalTokenAllocation
+            ? {
+                amount: allocation.additionalTokenAllocation.amount.toString(),
+                recipient: allocation.additionalTokenAllocation.recipient,
+                claimed: allocation.additionalTokenAllocation.claimed,
+                tokenAccountAddress: allocation.additionalTokenAllocation.tokenAccountAddress,
+              }
+            : undefined,
+          daoTreasuryTokens: allocation.daoTreasuryTokens
+            ? {
+                amount: allocation.daoTreasuryTokens.amount.toString(),
+                vaultAddress: allocation.daoTreasuryTokens.vaultAddress,
+              }
+            : undefined,
+          excludedHolders: excludedHolders.map(holder => ({
+            address: holder.address,
+            amount: holder.amount.toString(),
+            label: holder.label,
+          })),
+          balanceSnapshotSlot: allocation.balanceSnapshotSlot,
+          mintSupplySnapshot: allocation.mintSupplySnapshot
+            ? {
+                amount: allocation.mintSupplySnapshot.amount.toString(),
+                decimals: allocation.mintSupplySnapshot.decimals,
+              }
+            : undefined,
+          daoAddress: allocation.daoAddress,
+          launchAddress: allocation.launchAddress,
+          version: allocation.version,
+        })
+      : 'none';
+    const cacheKey = allocation
+      ? `supply_info_${mintAddress}_${allocationCacheKey}`
       : `supply_info_${mintAddress}_none`;
     const cached = this.getCached<TokenSupplyInfo>(cacheKey, config.cache.tickersTTL);
     if (cached !== null) return cached;
 
     try {
-      const mintPubkey = new PublicKey(mintAddress);
-      const mintInfo = await this.withRetry(() => getMint(this.connection, mintPubkey));
-      const rawSupply = mintInfo.supply.toString();
-      const totalSupplyBN = new BN(mintInfo.supply.toString());
-      const decimals = mintInfo.decimals;
+      let totalSupplyBN: BN;
+      let decimals: number;
+      if (allocation?.mintSupplySnapshot) {
+        totalSupplyBN = allocation.mintSupplySnapshot.amount;
+        decimals = allocation.mintSupplySnapshot.decimals;
+      } else {
+        const mintPubkey = new PublicKey(mintAddress);
+        const mintInfo = await this.withRetry(() => this.getMintInfo(mintPubkey));
+        totalSupplyBN = new BN(mintInfo.supply.toString());
+        decimals = mintInfo.decimals;
+      }
+      if (!Number.isInteger(decimals) || decimals < 0) {
+        throw new Error(`Invalid mint decimals for ${mintAddress}`);
+      }
+      const rawSupply = totalSupplyBN.toString();
       const divisor = Math.pow(10, decimals);
 
       const totalSupplyWithDecimals = Number(totalSupplyBN.toString()) / divisor;
@@ -198,26 +365,42 @@ export class SolanaService {
           circulatingSupplyBN = circulatingSupplyBN.sub(teamAmount);
         }
 
-        // Subtract additional token allocation from circulating supply (v0.7+ only)
-        // These tokens go to a specific recipient, not into general circulation
+        // Subtract additional token allocation only while it is unclaimed (v0.7+ only).
+        // Once claimed, those tokens are in the recipient's control and circulating
+        // unless the recipient is explicitly listed as an excluded holder.
         if (allocation.additionalTokenAllocation && 
+            !allocation.additionalTokenAllocation.claimed &&
             allocation.additionalTokenAllocation.amount.gt(new BN(0))) {
           circulatingSupplyBN = circulatingSupplyBN.sub(allocation.additionalTokenAllocation.amount);
         }
 
         // Subtract DAO treasury tokens (held in squads vault, protocol-controlled)
-        if (allocation.daoTreasuryTokens && 
+        if (allocation.daoTreasuryTokens &&
             allocation.daoTreasuryTokens.amount.gt(new BN(0))) {
           circulatingSupplyBN = circulatingSupplyBN.sub(allocation.daoTreasuryTokens.amount);
         }
 
+        // Subtract configured excluded holders (external/vesting/encumbered wallets,
+        // e.g. Laso's external wallet — tokens not "in the hands of others")
+        if (excludedHoldersTotal.gt(new BN(0))) {
+          circulatingSupplyBN = circulatingSupplyBN.sub(excludedHoldersTotal);
+        }
+
         // Special case: RNGR token has an initial token allocation that IS in circulation
         // This is a claimed portion from the additional token recipient that should be added back
         const RNGR_MINT = 'RNGRtJMbCveqCp7AC6U95KmrdKecFckaJZiWbPGmeta';
         const RNGR_INITIAL_ALLOCATION = new BN(192187500000); // 192,187.5 tokens with 6 decimals
         let initialTokenAllocationDetails: { amount: string; claimed: boolean } | undefined;
         
-        if (mintAddress === RNGR_MINT) {
+        // Add the known claimed tranche back only while the full additional
+        // allocation is still being subtracted. Once the launch reports the
+        // allocation fully claimed, none of it is subtracted and adding this
+        // tranche again would make circulating supply exceed total supply.
+        if (
+          mintAddress === RNGR_MINT &&
+          allocation.additionalTokenAllocation &&
+          !allocation.additionalTokenAllocation.claimed
+        ) {
           circulatingSupplyBN = circulatingSupplyBN.add(RNGR_INITIAL_ALLOCATION);
           initialTokenAllocationDetails = {
             amount: (Number(RNGR_INITIAL_ALLOCATION.toString()) / divisor).toString(),
@@ -225,9 +408,12 @@ export class SolanaService {
           };
         }
 
-        // Ensure we don't go negative
+        // A negative result means categories overlap or configuration is invalid.
+        // Returning a clamped 0 would hide a financial-accounting error.
         if (circulatingSupplyBN.isNeg()) {
-          circulatingSupplyBN = new BN(0);
+          throw new Error(
+            `Non-circulating allocations exceed total supply for ${mintAddress}`,
+          );
         }
 
         // Build allocation details for response (include all for transparency)
@@ -259,6 +445,17 @@ export class SolanaService {
             amount: (Number(allocation.daoTreasuryTokens.amount.toString()) / divisor).toString(),
             vaultAddress: allocation.daoTreasuryTokens.vaultAddress,
           } : undefined,
+          // Include every configured holder, including zero balances, so operators
+          // can distinguish an empty wallet from a missing configuration entry.
+          excludedHolders: allocation.excludedHolders && allocation.excludedHolders.length > 0
+            ? allocation.excludedHolders
+                .map(h => ({
+                  amount: (Number(h.amount.toString()) / divisor).toString(),
+                  address: h.address,
+                  label: h.label,
+                }))
+            : undefined,
+          balanceSnapshotSlot: allocation.balanceSnapshotSlot,
           daoAddress: allocation.daoAddress,
           launchAddress: allocation.launchAddress,
           version: allocation.version,
@@ -280,7 +477,9 @@ export class SolanaService {
       return result;
     } catch (error) {
       logger.error(`Error fetching supply info for ${mintAddress}:`, error);
-      throw new Error(`Failed to fetch supply info for token: ${mintAddress}`);
+      throw error instanceof Error
+        ? error
+        : new Error(`Failed to fetch supply info for token: ${mintAddress}`);
     }
   }
 }
diff --git a/src/services/supplyWithLaunchpadAllocation.ts b/src/services/supplyWithLaunchpadAllocation.ts
index 3acbfac..6be02d6 100644
--- a/src/services/supplyWithLaunchpadAllocation.ts
+++ b/src/services/supplyWithLaunchpadAllocation.ts
@@ -44,6 +44,13 @@ export async function getSupplyInfoWithLaunchpadAllocation(
       amount: allocation.daoTreasuryTokens.amount,
       vaultAddress: allocation.daoTreasuryTokens.vaultAddress?.toString(),
     },
+    excludedHolders: (allocation.excludedHolders ?? []).map((h) => ({
+      amount: h.amount,
+      address: h.wallet.toString(),
+      label: h.label,
+    })),
+    balanceSnapshotSlot: allocation.balanceSnapshotSlot,
+    mintSupplySnapshot: allocation.mintSupplySnapshot,
     daoAddress: allocation.daoAddress?.toString(),
     launchAddress: allocation.launchAddress?.toString(),
     version: allocation.version,
diff --git a/src/types/dexscreener.ts b/src/types/dexscreener.ts
index 9037142..1e3c5ae 100644
--- a/src/types/dexscreener.ts
+++ b/src/types/dexscreener.ts
@@ -7,8 +7,8 @@ export interface DexScreenerAsset {
   id: string;
   name: string;
   symbol: string;
-  totalSupply?: number;
-  circulatingSupply?: number;
+  totalSupply: number;
+  circulatingSupply: number;
   coinGeckoId?: string;
   coinMarketCapId?: string;
   metadata?: Record<string, string>;
diff --git a/tests/config.test.ts b/tests/config.test.ts
new file mode 100644
index 0000000..d7a0755
--- /dev/null
+++ b/tests/config.test.ts
@@ -0,0 +1,80 @@
+import { describe, it, expect } from 'bun:test';
+import { parseExcludedHolders } from '../src/config.js';
+
+// Two real, distinct base58 pubkeys used across the cases.
+const MINT = 'RNGRtJMbCveqCp7AC6U95KmrdKecFckaJZiWbPGmeta';
+const WALLET = 'SoLo9oxzLDpcq1dpqAgMwgce5WqkRDtNXK7EPnbmeta';
+const WALLET2 = 'So11111111111111111111111111111111111111112';
+
+describe('parseExcludedHolders', () => {
+  it('returns [] for empty / whitespace input', () => {
+    expect(parseExcludedHolders('')).toEqual([]);
+    expect(parseExcludedHolders('   ')).toEqual([]);
+  });
+
+  it('parses a mint:wallet entry without a label', () => {
+    const holders = parseExcludedHolders(`${MINT}:${WALLET}`);
+    expect(holders).toHaveLength(1);
+    expect(holders[0]!.mint).toBe(MINT);
+    expect(holders[0]!.wallet.toString()).toBe(WALLET);
+    expect(holders[0]!.label).toBeUndefined();
+  });
+
+  it('parses a mint:wallet:label entry', () => {
+    const holders = parseExcludedHolders(`${MINT}:${WALLET}:Laso external wallet`);
+    expect(holders).toHaveLength(1);
+    expect(holders[0]!.label).toBe('Laso external wallet');
+  });
+
+  it('parses multiple comma-separated entries', () => {
+    const holders = parseExcludedHolders(`${MINT}:${WALLET}:a, ${MINT}:${WALLET2}:b`);
+    expect(holders).toHaveLength(2);
+    expect(holders[0]!.wallet.toString()).toBe(WALLET);
+    expect(holders[1]!.wallet.toString()).toBe(WALLET2);
+    expect(holders[1]!.label).toBe('b');
+  });
+
+  it('trims surrounding whitespace on mint, wallet, and label', () => {
+    const holders = parseExcludedHolders(`  ${MINT} : ${WALLET} : spaced label  `);
+    expect(holders).toHaveLength(1);
+    expect(holders[0]!.mint).toBe(MINT);
+    expect(holders[0]!.wallet.toString()).toBe(WALLET);
+    expect(holders[0]!.label).toBe('spaced label');
+  });
+
+  it('ignores blank entries from a trailing/leading comma', () => {
+    const holders = parseExcludedHolders(`,${MINT}:${WALLET}, ,`);
+    expect(holders).toHaveLength(1);
+    expect(holders[0]!.wallet.toString()).toBe(WALLET);
+  });
+
+  it('throws on malformed entries so a typo cannot silently overstate circulating supply', () => {
+    expect(() => parseExcludedHolders('no-colon-here')).toThrow('Invalid EXCLUDED_CIRCULATING_WALLETS');
+    expect(() => parseExcludedHolders(`${MINT}:`)).toThrow('Invalid EXCLUDED_CIRCULATING_WALLETS');
+    expect(() => parseExcludedHolders(`:${WALLET}`)).toThrow('Invalid EXCLUDED_CIRCULATING_WALLETS');
+    expect(() => parseExcludedHolders(`not-a-pubkey:${WALLET}`)).toThrow('valid base58 pubkeys');
+    expect(() => parseExcludedHolders(`${MINT}:not-a-pubkey`)).toThrow('valid base58 pubkeys');
+  });
+
+  it('aborts the whole list if any entry is malformed', () => {
+    // The one valid entry must NOT be returned — fail fast, don't partially apply.
+    expect(() => parseExcludedHolders(`${MINT}:${WALLET}:good, garbage`)).toThrow();
+  });
+
+  it('dedupes exact mint:wallet duplicates so a balance is never subtracted twice', () => {
+    const holders = parseExcludedHolders(`${MINT}:${WALLET}:first, ${MINT}:${WALLET}:second`);
+    expect(holders).toHaveLength(1);
+    expect(holders[0]!.label).toBe('first'); // first occurrence wins
+  });
+
+  it('keeps the same wallet across different mints (dedupe is per mint:wallet)', () => {
+    const holders = parseExcludedHolders(`${MINT}:${WALLET}, ${WALLET2}:${WALLET}`);
+    expect(holders).toHaveLength(2);
+  });
+
+  it('treats an empty label after the second colon as undefined', () => {
+    const holders = parseExcludedHolders(`${MINT}:${WALLET}:`);
+    expect(holders).toHaveLength(1);
+    expect(holders[0]!.label).toBeUndefined();
+  });
+});
diff --git a/tests/helpers/testApp.ts b/tests/helpers/testApp.ts
index fdfc24c..19975d2 100644
--- a/tests/helpers/testApp.ts
+++ b/tests/helpers/testApp.ts
@@ -58,6 +58,9 @@ export function createMockLaunchpadService(): LaunchpadService {
       futarchyAmmLiquidity: { amount: new BN(0) },
       meteoraLpLiquidity: { amount: new BN(0) },
       daoTreasuryTokens: { amount: new BN(0) },
+      excludedHolders: [],
+      balanceSnapshotSlot: 100,
+      mintSupplySnapshot: { amount: new BN(1_000_000_000_000), decimals: 6 },
       totalNonCirculating: new BN(0),
     }),
   } as unknown as LaunchpadService;
diff --git a/tests/routes/dexscreener.test.ts b/tests/routes/dexscreener.test.ts
index d0f7e57..12faa51 100644
--- a/tests/routes/dexscreener.test.ts
+++ b/tests/routes/dexscreener.test.ts
@@ -2,6 +2,18 @@ import { describe, it, expect } from 'bun:test';
 import request from 'supertest';
 import { createTestApp } from '../helpers/testApp.js';
 import type { ExternalDatabaseService } from '../../src/services/externalDatabaseService.js';
+import type { FutarchyService } from '../../src/services/futarchyService.js';
+import type { LaunchpadService } from '../../src/services/launchpadService.js';
+import type { SolanaService } from '../../src/services/solanaService.js';
+
+const VALID_MINT = 'So11111111111111111111111111111111111111112';
+
+function assetMetadataService(): FutarchyService {
+  return {
+    getTokenMetadata: async () => ({ name: 'Wrapped SOL', symbol: 'SOL' }),
+    getTokenDecimals: async () => 9,
+  } as unknown as FutarchyService;
+}
 
 // Stub the served DB with canned user_pool_swaps-shaped rows (the aliased column
 // shape the migrated /events SQL returns) so we test the event-building transform:
@@ -19,6 +31,101 @@ function extDbReturning(rows: any[]): ExternalDatabaseService {
 }
 
 describe('DexScreener Routes', () => {
+  describe('GET /dexscreener/asset', () => {
+    it('returns 503 and does not cache a failed supply read', async () => {
+      let allocationCalls = 0;
+      let metadataCalls = 0;
+      const launchpadService = {
+        getTokenAllocationBreakdown: async () => {
+          allocationCalls++;
+          throw new Error('RPC connection refused');
+        },
+      } as unknown as LaunchpadService;
+      const app = createTestApp({
+        futarchyService: {
+          getTokenMetadata: async () => {
+            metadataCalls++;
+            return { name: 'Wrapped SOL', symbol: 'SOL' };
+          },
+          getTokenDecimals: async () => {
+            metadataCalls++;
+            return 9;
+          },
+        } as unknown as FutarchyService,
+        launchpadService,
+      });
+
+      const first = await request(app).get('/dexscreener/asset').query({ id: VALID_MINT });
+      const second = await request(app).get('/dexscreener/asset').query({ id: VALID_MINT });
+
+      expect(first.status).toBe(503);
+      expect(first.body.code).toBe('SUPPLY_UNAVAILABLE');
+      expect(second.status).toBe(503);
+      expect(allocationCalls).toBe(2);
+      expect(metadataCalls).toBe(0);
+    });
+
+    it('returns complete supply data when the allocation snapshot succeeds', async () => {
+      const launchpadService = {
+        getTokenAllocationBreakdown: async () => ({
+          version: 'v0.7',
+          teamPerformancePackage: { amount: { toString: () => '0' } },
+          futarchyAmmLiquidity: { amount: { toString: () => '0' } },
+          meteoraLpLiquidity: { amount: { toString: () => '0' } },
+          daoTreasuryTokens: { amount: { toString: () => '0' } },
+          excludedHolders: [],
+          balanceSnapshotSlot: 100,
+          mintSupplySnapshot: {
+            amount: { toString: () => '1000000000000' },
+            decimals: 6,
+          },
+          totalNonCirculating: { toString: () => '0' },
+        }),
+      } as unknown as LaunchpadService;
+      const solanaService = {
+        getSupplyInfo: async () => ({
+          totalSupply: '1000000',
+          circulatingSupply: '875000',
+        }),
+      } as unknown as SolanaService;
+      const app = createTestApp({
+        futarchyService: assetMetadataService(),
+        launchpadService,
+        solanaService,
+      });
+
+      const response = await request(app).get('/dexscreener/asset').query({ id: VALID_MINT });
+
+      expect(response.status).toBe(200);
+      expect(response.body.asset).toMatchObject({
+        id: VALID_MINT,
+        name: 'Wrapped SOL',
+        symbol: 'SOL',
+        totalSupply: 1000000,
+        circulatingSupply: 875000,
+        metadata: { decimals: '9' },
+      });
+    });
+
+    it('rejects numeric-prefix garbage instead of truncating it', async () => {
+      const solanaService = {
+        getSupplyInfo: async () => ({
+          totalSupply: '123abc',
+          circulatingSupply: '100',
+        }),
+      } as unknown as SolanaService;
+      const app = createTestApp({
+        futarchyService: assetMetadataService(),
+        solanaService,
+      });
+
+      const response = await request(app).get('/dexscreener/asset').query({ id: VALID_MINT });
+
+      expect(response.status).toBe(503);
+      expect(response.body.code).toBe('SUPPLY_UNAVAILABLE');
+    });
+  });
+
   describe('GET /dexscreener/events', () => {
     it('maps buy/sell legs, price, reserves, and txn/event indices from user_pool_swaps', async () => {
       // Two swaps in one signature (same txn → eventIndex 0,1), one in a second txn.
diff --git a/tests/routes/failurePaths.test.ts b/tests/routes/failurePaths.test.ts
index d9ef07f..dd88bcd 100644
--- a/tests/routes/failurePaths.test.ts
+++ b/tests/routes/failurePaths.test.ts
@@ -25,6 +25,22 @@ function failingExtDb(overrides: Partial<ExternalDatabaseService>): ExternalData
 }
 
 describe('Financial endpoint failure paths (infra failure → 5xx, never fake data)', () => {
+  describe('/api/supply/:mint', () => {
+    it('returns 500 when the allocation snapshot fails', async () => {
+      const launchpadService = {
+        getTokenAllocationBreakdown: async () => {
+          throw new Error('RPC connection refused');
+        },
+      } as unknown as LaunchpadService;
+      const app = createTestApp({ launchpadService });
+
+      const res = await request(app).get(`/api/supply/${VALID_MINT}`);
+
+      expect(res.status).toBe(500);
+      expect(res.body).not.toHaveProperty('data');
+    });
+  });
+
   describe('/api/supply/:mint/circulating', () => {
     it('returns 500 when the allocation breakdown fails (RPC outage), not circulating=total', async () => {
       const launchpadService = {
@@ -73,6 +89,24 @@ describe('Financial endpoint failure paths (infra failure → 5xx, never fake da
     });
   });
 
+  describe('/api/supply/:mint/jupiter/circulating', () => {
+    it('returns 500 when the allocation snapshot fails', async () => {
+      const launchpadService = {
+        getTokenAllocationBreakdown: async () => {
+          throw new Error('RPC connection refused');
+        },
+      } as unknown as LaunchpadService;
+      const app = createTestApp({ launchpadService });
+
+      const res = await request(app).get(
+        `/api/supply/${VALID_MINT}/jupiter/circulating`,
+      );
+
+      expect(res.status).toBe(500);
+      expect(res.body).not.toHaveProperty('circulatingSupply');
+    });
+  });
+
   describe('/api/tickers', () => {
     it('returns 5xx when the 24h metrics query fails (a failed query is not "zero volume")', async () => {
       const externalDatabaseService = failingExtDb({
diff --git a/tests/routes/root.test.ts b/tests/routes/root.test.ts
index 6ed58ed..da1d4ad 100644
--- a/tests/routes/root.test.ts
+++ b/tests/routes/root.test.ts
@@ -44,6 +44,8 @@ describe('Root Routes', () => {
       expect(response.body).toHaveProperty('supplyBreakdown');
       expect(response.body.supplyBreakdown).toHaveProperty('description');
       expect(response.body.supplyBreakdown).toHaveProperty('circulatingSupply');
+      expect(response.body.supplyBreakdown).toHaveProperty('excludedHolders');
+      expect(response.body.supplyBreakdown.excludedHolders).toContain('direct SPL token holder balances');
     });
 
     it('describes itself as a read-only, Dune-free API', async () => {
diff --git a/tests/routes/supply.test.ts b/tests/routes/supply.test.ts
index 537fd07..8a262fe 100644
--- a/tests/routes/supply.test.ts
+++ b/tests/routes/supply.test.ts
@@ -1,6 +1,9 @@
 import { describe, it, expect } from 'bun:test';
+import BN from 'bn.js';
 import request from 'supertest';
 import { createTestApp } from '../helpers/testApp.js';
+import type { LaunchpadService } from '../../src/services/launchpadService.js';
+import type { SolanaService } from '../../src/services/solanaService.js';
 
 const app = createTestApp();
 
@@ -54,10 +57,63 @@ describe('Supply Routes', () => {
   describe('GET /api/supply/:mintAddress/circulating', () => {
     it('should reject invalid mint address', async () => {
       const response = await request(app).get(`/api/supply/${invalidAddress}/circulating`);
-      
+
       expect(response.status).toBe(400);
       expect(response.body.error).toContain('not a valid Solana public key');
     });
+
+    it('surfaces excluded holders in the allocation breakdown', async () => {
+      const holderAddress = 'SoLo9oxzLDpcq1dpqAgMwgce5WqkRDtNXK7EPnbmeta';
+      const launchpadService = {
+        getTokenAllocationBreakdown: async () => ({
+          version: 'v0.7',
+          teamPerformancePackage: { amount: new BN(0) },
+          futarchyAmmLiquidity: { amount: new BN(0) },
+          meteoraLpLiquidity: { amount: new BN(0) },
+          daoTreasuryTokens: { amount: new BN(0) },
+          excludedHolders: [{ wallet: { toString: () => holderAddress }, label: 'Laso external', amount: new BN(100) }],
+          balanceSnapshotSlot: 123,
+          mintSupplySnapshot: { amount: new BN(1_000_000_000_000), decimals: 6 },
+          totalNonCirculating: new BN(100),
+        }),
+      } as unknown as LaunchpadService;
+      let capturedAllocation: any;
+      const solanaService = {
+        getSupplyInfo: async (_mint: string, allocation: any) => {
+          capturedAllocation = allocation;
+          return {
+            mint: validMintAddress,
+            totalSupply: '1000000',
+            circulatingSupply: '999900',
+            decimals: 6,
+            rawTotalSupply: '1000000000000',
+            allocation: {
+              excludedHolders: [{ amount: '0.0001', address: holderAddress, label: 'Laso external' }],
+              balanceSnapshotSlot: 123,
+            },
+          };
+        },
+      } as unknown as SolanaService;
+      const testApp = createTestApp({ launchpadService, solanaService });
+
+      const response = await request(testApp).get(`/api/supply/${validMintAddress}/circulating`);
+
+      expect(response.status).toBe(200);
+      expect(response.body.result).toBe('999900');
+      expect(response.body.allocation.excludedHolders).toEqual([
+        { amount: '0.0001', address: holderAddress, label: 'Laso external' },
+      ]);
+      expect(response.body.allocation.balanceSnapshotSlot).toBe(123);
+      // The breakdown's excludedHolders must be mapped (wallet -> address) and
+      // forwarded to getSupplyInfo — guards supplyWithLaunchpadAllocation wiring.
+      expect(capturedAllocation.excludedHolders).toHaveLength(1);
+      expect(capturedAllocation.excludedHolders[0].address).toBe(holderAddress);
+      expect(capturedAllocation.excludedHolders[0].label).toBe('Laso external');
+      expect(capturedAllocation.excludedHolders[0].amount.toString()).toBe('100');
+      expect(capturedAllocation.balanceSnapshotSlot).toBe(123);
+      expect(capturedAllocation.mintSupplySnapshot.amount.toString()).toBe('1000000000000');
+      expect(capturedAllocation.mintSupplySnapshot.decimals).toBe(6);
+    });
   });
 
   describe('GET /api/supply/:mintAddress/jupiter/circulating', () => {
@@ -67,6 +123,21 @@ describe('Supply Routes', () => {
       expect(response.status).toBe(400);
       expect(response.body.error).toContain('not a valid Solana public key');
     });
+
+    it('rejects malformed numeric supply instead of truncating it', async () => {
+      const solanaService = {
+        getSupplyInfo: async () => ({
+          circulatingSupply: '12abc',
+        }),
+      } as unknown as SolanaService;
+      const testApp = createTestApp({ solanaService });
+
+      const response = await request(testApp)
+        .get(`/api/supply/${validMintAddress}/jupiter/circulating`);
+
+      expect(response.status).toBe(500);
+      expect(response.body).not.toHaveProperty('circulatingSupply');
+    });
   });
 
   describe('GET /api/supply/:mintAddress/jupiter/total', () => {
diff --git a/tests/services/launchpadService.test.ts b/tests/services/launchpadService.test.ts
index 98ad469..078bdc3 100644
--- a/tests/services/launchpadService.test.ts
+++ b/tests/services/launchpadService.test.ts
@@ -1,18 +1,115 @@
 /**
- * Regression tests for the getTokenAllocationBreakdown error contract.
+ * Regression tests for the allocation snapshot error contract.
  *
- * An empty breakdown (zero locked allocations) is ONLY correct when the token
- * genuinely has no launch / an incomplete launch. An infrastructure failure
- * must REJECT — a swallowed error here would zero out every locked allocation
- * and serve circulating supply = total supply during any RPC blip (the exact
- * bug this suite pins down).
+ * Mint supply and every live non-circulating balance must come from one
+ * contextual RPC batch. Infrastructure failures must reject rather than
+ * silently returning zero allocations.
  */
 
-import { describe, it, expect } from 'bun:test';
-import { PublicKey } from '@solana/web3.js';
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
+import {
+  AccountLayout,
+  AccountState,
+  getAssociatedTokenAddress,
+  MintLayout,
+  TOKEN_2022_PROGRAM_ID,
+  TOKEN_PROGRAM_ID,
+} from '@solana/spl-token';
+import { PublicKey, type AccountInfo } from '@solana/web3.js';
+import BN from 'bn.js';
+import { config } from '../../src/config.js';
 import { LaunchpadService } from '../../src/services/launchpadService.js';
 
 const MINT = new PublicKey('SoLo9oxzLDpcq1dpqAgMwgce5WqkRDtNXK7EPnbmeta');
+const HOLDER = new PublicKey('DMB74TZgN7Rqfwtqqm3VQBgKBb2WYPdBqVtHbvB4LLeV');
+const HOLDER_2 = new PublicKey('5FPGRzY9ArJFwY2Hp2y2eqMzVewyWCBox7esmpuZfCvE');
+const ACCOUNT_A = new PublicKey('So11111111111111111111111111111111111111112');
+const ACCOUNT_B = new PublicKey('11111111111111111111111111111111');
+const OTHER_MINT = 'So11111111111111111111111111111111111111112';
+const ZERO_KEY = new PublicKey(new Uint8Array(32));
+
+function accountInfo(
+  data: Buffer,
+  tokenProgramId = TOKEN_PROGRAM_ID,
+): AccountInfo<Buffer> {
+  return {
+    data,
+    executable: false,
+    lamports: 1,
+    owner: tokenProgramId,
+    rentEpoch: 0,
+  };
+}
+
+function mintAccountInfo(
+  supply = 1_000_000n,
+  decimals = 6,
+  tokenProgramId = TOKEN_PROGRAM_ID,
+): AccountInfo<Buffer> {
+  const data = Buffer.alloc(MintLayout.span);
+  MintLayout.encode({
+    mintAuthorityOption: 0,
+    mintAuthority: ZERO_KEY,
+    supply,
+    decimals,
+    isInitialized: true,
+    freezeAuthorityOption: 0,
+    freezeAuthority: ZERO_KEY,
+  }, data);
+  return accountInfo(data, tokenProgramId);
+}
+
+function tokenAccountInfo(
+  owner: PublicKey,
+  amount: bigint,
+  mint = MINT,
+  tokenProgramId = TOKEN_PROGRAM_ID,
+): AccountInfo<Buffer> {
+  const data = Buffer.alloc(AccountLayout.span);
+  AccountLayout.encode({
+    mint,
+    owner,
+    amount,
+    delegateOption: 0,
+    delegate: ZERO_KEY,
+    state: AccountState.Initialized,
+    isNativeOption: 0,
+    isNative: 0n,
+    delegatedAmount: 0n,
+    closeAuthorityOption: 0,
+    closeAuthority: ZERO_KEY,
+  }, data);
+  return accountInfo(data, tokenProgramId);
+}
+
+function discovery(
+  accounts: Array<{ pubkey: PublicKey; info: AccountInfo<Buffer> }>,
+  slot = 100,
+) {
+  return {
+    context: { apiVersion: 'test', slot },
+    value: accounts.map(({ pubkey, info }) => ({ pubkey, account: info })),
+  };
+}
+
+function snapshotStub() {
+  return {
+    excludedHolders: [],
+    performancePackageAmount: new BN(0),
+    daoTreasuryAmount: new BN(0),
+    mintSupply: { amount: new BN(1_000_000), decimals: 6 },
+    tokenProgramId: TOKEN_PROGRAM_ID,
+    slot: 100,
+  };
+}
+
+beforeEach(() => {
+  config.circulating.excludedHolders.length = 0;
+});
+
+afterEach(() => {
+  config.circulating.excludedHolders.length = 0;
+});
 
 describe('LaunchpadService.getTokenAllocationBreakdown', () => {
   it('propagates infrastructure failures instead of returning an empty breakdown', async () => {
@@ -24,32 +121,350 @@ describe('LaunchpadService.getTokenAllocationBreakdown', () => {
     await expect(svc.getTokenAllocationBreakdown(MINT)).rejects.toThrow('RPC connection refused');
   });
 
-  it('returns an empty breakdown when the token genuinely has no launch', async () => {
+  it('returns an empty allocation with a live mint snapshot when no launch exists', async () => {
     const svc = new LaunchpadService();
     (svc as any).getLaunchByBaseMint = async () => null;
+    (svc as any).getLiveBalanceSnapshot = async () => snapshotStub();
 
     const breakdown = await svc.getTokenAllocationBreakdown(MINT);
 
     expect(breakdown.teamPerformancePackage.amount.isZero()).toBe(true);
-    expect(breakdown.futarchyAmmLiquidity.amount.isZero()).toBe(true);
-    expect(breakdown.meteoraLpLiquidity.amount.isZero()).toBe(true);
     expect(breakdown.totalNonCirculating.isZero()).toBe(true);
+    expect(breakdown.balanceSnapshotSlot).toBe(100);
+    expect(breakdown.mintSupplySnapshot.amount.toString()).toBe('1000000');
   });
 
-  it('returns an empty breakdown (with launch metadata) for an incomplete launch', async () => {
+  it('returns an empty allocation with launch metadata for an incomplete launch', async () => {
     const svc = new LaunchpadService();
-    const launchAddress = new PublicKey('5FPGRzY9ArJFwY2Hp2y2eqMzVewyWCBox7esmpuZfCvE');
+    const launchAddress = HOLDER_2;
     (svc as any).getLaunchByBaseMint = async () => ({
       launchAddress,
       baseMint: MINT,
       version: 'v0.7',
       dao: undefined,
     });
+    (svc as any).getLiveBalanceSnapshot = async () => snapshotStub();
 
     const breakdown = await svc.getTokenAllocationBreakdown(MINT);
 
     expect(breakdown.version).toBe('v0.7');
     expect(breakdown.launchAddress?.equals(launchAddress)).toBe(true);
     expect(breakdown.totalNonCirculating.isZero()).toBe(true);
+    expect(breakdown.excludedHolders).toEqual([]);
+    expect(breakdown.mintSupplySnapshot.decimals).toBe(6);
+  });
+
+  it('derives the additional-recipient ATA from the snapshotted token program', async () => {
+    const svc = new LaunchpadService();
+    const recipient = HOLDER;
+    const expectedAta = await getAssociatedTokenAddress(
+      MINT,
+      recipient,
+      true,
+      TOKEN_2022_PROGRAM_ID,
+    );
+    (svc as any).getLaunchByBaseMint = async () => ({
+      launchAddress: HOLDER_2,
+      baseMint: MINT,
+      performancePackageGrantee: HOLDER,
+      performancePackageTokenAmount: new BN(0),
+      state: { completed: {} },
+      dao: ACCOUNT_A,
+      version: 'v0.7',
+      additionalTokensAmount: new BN(100),
+      additionalTokensRecipient: recipient,
+      additionalTokensClaimed: false,
+    });
+    (svc as any).futarchyClient = {
+      fetchDao: async () => ({ quoteMint: undefined }),
+    };
+    (svc as any).getPerformancePackageAddress = () => ACCOUNT_B;
+    (svc as any).getFutarchyAmmLiquidity = async () => ({ amount: new BN(0) });
+    (svc as any).getLiveBalanceSnapshot = async () => ({
+      ...snapshotStub(),
+      tokenProgramId: TOKEN_2022_PROGRAM_ID,
+    });
+
+    const breakdown = await svc.getTokenAllocationBreakdown(MINT);
+
+    expect(
+      breakdown.additionalTokenAllocation?.tokenAccountAddress?.equals(expectedAta),
+    ).toBe(true);
+  });
+});
+
+describe('LaunchpadService allocation snapshots', () => {
+  it('resolves no configured holders without RPC when only holder balances are requested', async () => {
+    const svc = new LaunchpadService();
+    let called = false;
+    (svc as any).connection = {
+      getTokenAccountsByOwner: async () => {
+        called = true;
+        return discovery([]);
+      },
+    };
+
+    expect(await (svc as any).getExcludedHolderBalances(MINT)).toEqual([]);
+    expect(called).toBe(false);
+  });
+
+  it('reads mint supply and sums every holder account in one contextual batch', async () => {
+    config.circulating.excludedHolders.push({
+      mint: MINT.toString(),
+      wallet: HOLDER,
+      label: 'external',
+    });
+    const accounts = [
+      { pubkey: ACCOUNT_A, info: tokenAccountInfo(HOLDER, 100n) },
+      { pubkey: ACCOUNT_B, info: tokenAccountInfo(HOLDER, 25n) },
+    ];
+    const accountMap = new Map([
+      [MINT.toString(), mintAccountInfo(2_000_000n, 6)],
+      ...accounts.map(({ pubkey, info }) => [pubkey.toString(), info] as const),
+    ]);
+    const svc = new LaunchpadService();
+    let batchCalls = 0;
+    (svc as any).connection = {
+      getTokenAccountsByOwner: async () => discovery(accounts),
+      getMultipleAccountsInfoAndContext: async (addresses: PublicKey[]) => {
+        batchCalls++;
+        return {
+          context: { apiVersion: 'test', slot: 321 },
+          value: addresses.map(address => accountMap.get(address.toString()) ?? null),
+        };
+      },
+    };
+
+    const snapshot = await (svc as any).getLiveBalanceSnapshot(MINT);
+
+    expect(batchCalls).toBe(1);
+    expect(snapshot.slot).toBe(321);
+    expect(snapshot.mintSupply.amount.toString()).toBe('2000000');
+    expect(snapshot.mintSupply.decimals).toBe(6);
+    expect(snapshot.excludedHolders[0].amount.toString()).toBe('125');
+    expect(snapshot.excludedHolders[0].label).toBe('external');
+  });
+
+  it('yields zero when a configured holder owns no accounts for the mint', async () => {
+    config.circulating.excludedHolders.push({ mint: MINT.toString(), wallet: HOLDER });
+    const svc = new LaunchpadService();
+    (svc as any).connection = {
+      getTokenAccountsByOwner: async () => discovery([]),
+      getMultipleAccountsInfoAndContext: async () => ({
+        context: { apiVersion: 'test', slot: 100 },
+        value: [mintAccountInfo()],
+      }),
+    };
+
+    const snapshot = await (svc as any).getLiveBalanceSnapshot(MINT);
+
+    expect(snapshot.excludedHolders[0].amount.isZero()).toBe(true);
+  });
+
+  it('propagates discovery failures instead of returning a silent zero', async () => {
+    config.circulating.excludedHolders.push({ mint: MINT.toString(), wallet: HOLDER });
+    const svc = new LaunchpadService();
+    (svc as any).connection = {
+      getTokenAccountsByOwner: async () => {
+        throw new Error('RPC connection refused');
+      },
+    };
+
+    await expect((svc as any).getLiveBalanceSnapshot(MINT)).rejects.toThrow(
+      'RPC connection refused',
+    );
+  });
+
+  it('fails closed when a discovered token account is absent from the batch', async () => {
+    config.circulating.excludedHolders.push({ mint: MINT.toString(), wallet: HOLDER });
+    const accounts = [{ pubkey: ACCOUNT_A, info: tokenAccountInfo(HOLDER, 100n) }];
+    const svc = new LaunchpadService();
+    (svc as any).connection = {
+      getTokenAccountsByOwner: async () => discovery(accounts),
+      getMultipleAccountsInfoAndContext: async () => ({
+        context: { apiVersion: 'test', slot: 100 },
+        value: [mintAccountInfo(), null],
+      }),
+    };
+
+    await expect((svc as any).getLiveBalanceSnapshot(MINT)).rejects.toThrow(
+      'was absent from balance snapshot',
+    );
+  });
+
+  it('ignores holders configured for another mint without RPC', async () => {
+    config.circulating.excludedHolders.push({ mint: OTHER_MINT, wallet: HOLDER });
+    const svc = new LaunchpadService();
+    let called = false;
+    (svc as any).connection = {
+      getTokenAccountsByOwner: async () => {
+        called = true;
+        return discovery([]);
+      },
+    };
+
+    expect(await (svc as any).getExcludedHolderBalances(MINT)).toEqual([]);
+    expect(called).toBe(false);
+  });
+
+  it('retries the complete snapshot when account topology changes around it', async () => {
+    config.circulating.excludedHolders.push({ mint: MINT.toString(), wallet: HOLDER });
+    const accountA = [{ pubkey: ACCOUNT_A, info: tokenAccountInfo(HOLDER, 10n) }];
+    const accountB = [{ pubkey: ACCOUNT_B, info: tokenAccountInfo(HOLDER, 20n) }];
+    const discoveries = [accountA, accountB, accountB, accountB];
+    const svc = new LaunchpadService();
+    let discoveryCalls = 0;
+    let batchCalls = 0;
+    (svc as any).connection = {
+      getTokenAccountsByOwner: async () =>
+        discovery(discoveries[discoveryCalls++] ?? accountB, 100 + discoveryCalls),
+      getMultipleAccountsInfoAndContext: async (addresses: PublicKey[]) => {
+        batchCalls++;
+        return {
+          context: { apiVersion: 'test', slot: 200 + batchCalls },
+          value: addresses.map(address => {
+            if (address.equals(MINT)) return mintAccountInfo();
+            return tokenAccountInfo(HOLDER, address.equals(ACCOUNT_A) ? 10n : 20n);
+          }),
+        };
+      },
+    };
+
+    const snapshot = await (svc as any).getLiveBalanceSnapshot(MINT);
+
+    expect(discoveryCalls).toBe(4);
+    expect(batchCalls).toBe(2);
+    expect(snapshot.excludedHolders[0].amount.toString()).toBe('20');
+  });
+
+  it('reads performance-package and treasury balances in the mint-supply batch', async () => {
+    const performanceAta = await getAssociatedTokenAddress(
+      MINT,
+      ACCOUNT_A,
+      true,
+      TOKEN_PROGRAM_ID,
+    );
+    const treasuryAta = await getAssociatedTokenAddress(
+      MINT,
+      ACCOUNT_B,
+      true,
+      TOKEN_PROGRAM_ID,
+    );
+    const svc = new LaunchpadService();
+    let requested: string[] = [];
+    (svc as any).connection = {
+      getTokenAccountsByOwner: async () => discovery([]),
+      getMultipleAccountsInfoAndContext: async (addresses: PublicKey[]) => {
+        requested = addresses.map(address => address.toString());
+        return {
+          context: { apiVersion: 'test', slot: 444 },
+          value: addresses.map(address => {
+            if (address.equals(MINT)) return mintAccountInfo(9_000_000n);
+            if (address.equals(performanceAta)) return tokenAccountInfo(HOLDER, 75n);
+            if (address.equals(treasuryAta)) return tokenAccountInfo(HOLDER, 25n);
+            return null;
+          }),
+        };
+      },
+    };
+
+    const snapshot = await (svc as any).getLiveBalanceSnapshot(MINT, ACCOUNT_A, ACCOUNT_B);
+
+    expect(requested).toContain(performanceAta.toString());
+    expect(requested).toContain(treasuryAta.toString());
+    expect(snapshot.slot).toBe(444);
+    expect(snapshot.mintSupply.amount.toString()).toBe('9000000');
+    expect(snapshot.performancePackageAmount.toString()).toBe('75');
+    expect(snapshot.daoTreasuryAmount.toString()).toBe('25');
+  });
+
+  it('selects Token-2022 ATAs from the same contextual batch', async () => {
+    const performanceAta = await getAssociatedTokenAddress(
+      MINT,
+      ACCOUNT_A,
+      true,
+      TOKEN_2022_PROGRAM_ID,
+    );
+    const treasuryAta = await getAssociatedTokenAddress(
+      MINT,
+      ACCOUNT_B,
+      true,
+      TOKEN_2022_PROGRAM_ID,
+    );
+    const svc = new LaunchpadService();
+    (svc as any).connection = {
+      getTokenAccountsByOwner: async () => discovery([]),
+      getMultipleAccountsInfoAndContext: async (addresses: PublicKey[]) => ({
+        context: { apiVersion: 'test', slot: 555 },
+        value: addresses.map(address => {
+          if (address.equals(MINT)) {
+            return mintAccountInfo(8_000_000n, 6, TOKEN_2022_PROGRAM_ID);
+          }
+          if (address.equals(performanceAta)) {
+            return tokenAccountInfo(
+              HOLDER,
+              80n,
+              MINT,
+              TOKEN_2022_PROGRAM_ID,
+            );
+          }
+          if (address.equals(treasuryAta)) {
+            return tokenAccountInfo(
+              HOLDER,
+              20n,
+              MINT,
+              TOKEN_2022_PROGRAM_ID,
+            );
+          }
+          return null;
+        }),
+      }),
+    };
+
+    const snapshot = await (svc as any).getLiveBalanceSnapshot(
+      MINT,
+      ACCOUNT_A,
+      ACCOUNT_B,
+    );
+
+    expect(snapshot.slot).toBe(555);
+    expect(snapshot.mintSupply.amount.toString()).toBe('8000000');
+    expect(snapshot.tokenProgramId.equals(TOKEN_2022_PROGRAM_ID)).toBe(true);
+    expect(snapshot.performancePackageAmount.toString()).toBe('80');
+    expect(snapshot.daoTreasuryAmount.toString()).toBe('20');
+  });
+
+  it('fails closed when account topology keeps changing', async () => {
+    config.circulating.excludedHolders.push({ mint: MINT.toString(), wallet: HOLDER });
+    const svc = new LaunchpadService();
+    let calls = 0;
+    (svc as any).connection = {
+      getTokenAccountsByOwner: async () => {
+        const account = calls++ % 2 === 0 ? ACCOUNT_A : ACCOUNT_B;
+        return discovery([{ pubkey: account, info: tokenAccountInfo(HOLDER, 10n) }]);
+      },
+      getMultipleAccountsInfoAndContext: async (addresses: PublicKey[]) => ({
+        context: { apiVersion: 'test', slot: 100 },
+        value: addresses.map(address =>
+          address.equals(MINT) ? mintAccountInfo() : tokenAccountInfo(HOLDER, 10n)),
+      }),
+    };
+
+    await expect((svc as any).getLiveBalanceSnapshot(MINT)).rejects.toThrow(
+      'Token-account topology changed',
+    );
+    expect(calls).toBe(6);
+  });
+
+  it('bounds allocation cache entries and evicts the oldest entry', () => {
+    const svc = new LaunchpadService();
+
+    for (let index = 0; index <= 1000; index++) {
+      (svc as any).setCache(`allocation-${index}`, index);
+    }
+
+    expect((svc as any).cache.size).toBe(1000);
+    expect((svc as any).cache.has('allocation-0')).toBe(false);
+    expect((svc as any).cache.get('allocation-1000')?.data).toBe(1000);
   });
 });
diff --git a/tests/services/solanaService.test.ts b/tests/services/solanaService.test.ts
new file mode 100644
index 0000000..7f85f41
--- /dev/null
+++ b/tests/services/solanaService.test.ts
@@ -0,0 +1,325 @@
+/**
+ * Unit tests for SolanaService.getSupplyInfo circulating-supply math, focused on
+ * the MET-570 excluded-holders exclusion. RPC is bypassed by overriding the
+ * private withRetry wrapper (which normally runs getMint), so no network is hit.
+ */
+
+import { describe, it, expect } from 'bun:test';
+import {
+  MintLayout,
+  TOKEN_2022_PROGRAM_ID,
+} from '@solana/spl-token';
+import { PublicKey, type AccountInfo } from '@solana/web3.js';
+import BN from 'bn.js';
+import { SolanaService } from '../../src/services/solanaService.js';
+import type { TokenAllocationInput } from '../../src/services/solanaService.js';
+
+const MINT = 'So11111111111111111111111111111111111111112';
+const RNGR_MINT = 'RNGRtJMbCveqCp7AC6U95KmrdKecFckaJZiWbPGmeta';
+const HOLDER_A = 'SoLo9oxzLDpcq1dpqAgMwgce5WqkRDtNXK7EPnbmeta';
+const HOLDER_B = 'DMB74TZgN7Rqfwtqqm3VQBgKBb2WYPdBqVtHbvB4LLeV';
+
+const DECIMALS = 6;
+const ONE = new BN(10).pow(new BN(DECIMALS));
+// 1,000,000 tokens total supply (raw = 1e6 * 1e6).
+const TOTAL_RAW = new BN(1_000_000).mul(ONE);
+const ZERO_KEY = new PublicKey(new Uint8Array(32));
+
+function token2022MintAccountInfo(
+  supply: bigint,
+  decimals: number,
+): AccountInfo<Buffer> {
+  const data = Buffer.alloc(MintLayout.span);
+  MintLayout.encode({
+    mintAuthorityOption: 0,
+    mintAuthority: ZERO_KEY,
+    supply,
+    decimals,
+    isInitialized: true,
+    freezeAuthorityOption: 0,
+    freezeAuthority: ZERO_KEY,
+  }, data);
+  return {
+    data,
+    executable: false,
+    lamports: 1,
+    owner: TOKEN_2022_PROGRAM_ID,
+    rentEpoch: 0,
+  };
+}
+
+function serviceWithSupply(rawSupply: BN): SolanaService {
+  const svc = new SolanaService();
+  // withRetry normally executes () => getMint(...); short-circuit it to a fake mint.
+  (svc as any).withRetry = async () => ({
+    supply: BigInt(rawSupply.toString()),
+    decimals: DECIMALS,
+  });
+  return svc;
+}
+
+const baseAllocation = (): TokenAllocationInput => ({
+  teamPerformancePackage: { amount: new BN(0) },
+  futarchyAmmLiquidity: { amount: new BN(0) },
+  meteoraLpLiquidity: { amount: new BN(0) },
+});
+
+describe('SolanaService.getSupplyInfo — excluded holders', () => {
+  it('reads standalone Token-2022 total supply using the mint account owner', async () => {
+    const svc = new SolanaService();
+    (svc as any).connection = {
+      getAccountInfo: async () =>
+        token2022MintAccountInfo(BigInt(TOTAL_RAW.toString()), DECIMALS),
+    };
+
+    expect(await svc.getTotalSupply(MINT)).toBe('1000000');
+    const info = await svc.getSupplyInfo(MINT);
+    expect(info.totalSupply).toBe('1000000');
+    expect(info.circulatingSupply).toBe('1000000');
+  });
+
+  it('uses the mint supply captured with allocation balances without another RPC read', async () => {
+    const svc = new SolanaService();
+    (svc as any).withRetry = async () => {
+      throw new Error('mint RPC should not be called');
+    };
+
+    const info = await svc.getSupplyInfo(MINT, {
+      ...baseAllocation(),
+      balanceSnapshotSlot: 456,
+      mintSupplySnapshot: {
+        amount: TOTAL_RAW,
+        decimals: DECIMALS,
+      },
+      excludedHolders: [
+        { address: HOLDER_A, amount: new BN(100_000).mul(ONE) },
+      ],
+    });
+
+    expect(info.totalSupply).toBe('1000000');
+    expect(info.circulatingSupply).toBe('900000');
+    expect(info.allocation?.balanceSnapshotSlot).toBe(456);
+  });
+
+  it('subtracts configured excluded-holder balances from circulating supply', async () => {
+    const svc = serviceWithSupply(TOTAL_RAW);
+    const info = await svc.getSupplyInfo(MINT, {
+      ...baseAllocation(),
+      balanceSnapshotSlot: 123,
+      excludedHolders: [
+        { address: HOLDER_A, label: 'external', amount: new BN(100_000).mul(ONE) },
+        { address: HOLDER_B, label: 'vesting', amount: new BN(50_000).mul(ONE) },
+      ],
+    });
+
+    expect(info.totalSupply).toBe('1000000');
+    // 1,000,000 - 100,000 - 50,000 = 850,000
+    expect(info.circulatingSupply).toBe('850000');
+    expect(info.allocation?.excludedHolders).toEqual([
+      { amount: '100000', address: HOLDER_A, label: 'external' },
+      { amount: '50000', address: HOLDER_B, label: 'vesting' },
+    ]);
+    expect(info.allocation?.balanceSnapshotSlot).toBe(123);
+  });
+
+  it('surfaces zero-balance holders so configuration remains observable', async () => {
+    const svc = serviceWithSupply(TOTAL_RAW);
+    const info = await svc.getSupplyInfo(MINT, {
+      ...baseAllocation(),
+      excludedHolders: [
+        { address: HOLDER_A, label: 'external', amount: new BN(100_000).mul(ONE) },
+        { address: HOLDER_B, label: 'empty', amount: new BN(0) },
+      ],
+    });
+
+    expect(info.circulatingSupply).toBe('900000');
+    expect(info.allocation?.excludedHolders).toEqual([
+      { amount: '100000', address: HOLDER_A, label: 'external' },
+      { amount: '0', address: HOLDER_B, label: 'empty' },
+    ]);
+  });
+
+  it('leaves circulating == total when no excluded holders are passed', async () => {
+    const svc = serviceWithSupply(TOTAL_RAW);
+    const info = await svc.getSupplyInfo(MINT, baseAllocation());
+
+    expect(info.circulatingSupply).toBe('1000000');
+    expect(info.allocation?.excludedHolders).toBeUndefined();
+  });
+
+  it('subtracts additional allocation only while it is unclaimed', async () => {
+    const svc = serviceWithSupply(TOTAL_RAW);
+    const amount = new BN(25_000).mul(ONE);
+
+    const unclaimed = await svc.getSupplyInfo(MINT, {
+      ...baseAllocation(),
+      additionalTokenAllocation: {
+        amount,
+        recipient: HOLDER_A,
+        claimed: false,
+      },
+    });
+    const claimed = await svc.getSupplyInfo(MINT, {
+      ...baseAllocation(),
+      additionalTokenAllocation: {
+        amount,
+        recipient: HOLDER_A,
+        claimed: true,
+      },
+    });
+
+    expect(unclaimed.circulatingSupply).toBe('975000');
+    expect(claimed.circulatingSupply).toBe('1000000');
+    expect(unclaimed.allocation?.additionalTokenAllocation?.claimed).toBe(false);
+    expect(claimed.allocation?.additionalTokenAllocation?.claimed).toBe(true);
+  });
+
+  it('does not add the RNGR claimed tranche after the full allocation is claimed', async () => {
+    const svc = serviceWithSupply(TOTAL_RAW);
+    const info = await svc.getSupplyInfo(RNGR_MINT, {
+      ...baseAllocation(),
+      additionalTokenAllocation: {
+        amount: new BN(250_000).mul(ONE),
+        recipient: HOLDER_A,
+        claimed: true,
+      },
+    });
+
+    expect(info.circulatingSupply).toBe('1000000');
+    expect(info.allocation?.initialTokenAllocation).toBeUndefined();
+  });
+
+  it('adds the RNGR claimed tranche back while the remaining allocation is unclaimed', async () => {
+    const svc = serviceWithSupply(TOTAL_RAW);
+    const info = await svc.getSupplyInfo(RNGR_MINT, {
+      ...baseAllocation(),
+      additionalTokenAllocation: {
+        amount: new BN(250_000).mul(ONE),
+        recipient: HOLDER_A,
+        claimed: false,
+      },
+    });
+
+    expect(info.circulatingSupply).toBe('942187.5');
+    expect(info.allocation?.initialTokenAllocation).toEqual({
+      amount: '192187.5',
+      claimed: true,
+    });
+  });
+
+  it('allows a claimed additional recipient to be excluded by its live balance', async () => {
+    const svc = serviceWithSupply(TOTAL_RAW);
+    const info = await svc.getSupplyInfo(MINT, {
+      ...baseAllocation(),
+      additionalTokenAllocation: {
+        amount: new BN(25_000).mul(ONE),
+        recipient: HOLDER_A,
+        claimed: true,
+      },
+      excludedHolders: [
+        { address: HOLDER_A, amount: new BN(10_000).mul(ONE) },
+      ],
+    });
+
+    expect(info.circulatingSupply).toBe('990000');
+  });
+
+  it('rejects an excluded holder that overlaps the team package owner', async () => {
+    const svc = serviceWithSupply(TOTAL_RAW);
+
+    await expect(svc.getSupplyInfo(MINT, {
+      ...baseAllocation(),
+      teamPerformancePackage: {
+        amount: new BN(100_000).mul(ONE),
+        address: HOLDER_A,
+      },
+      excludedHolders: [
+        { address: HOLDER_A, amount: new BN(100_000).mul(ONE) },
+      ],
+    })).rejects.toThrow('overlaps the team performance package allocation');
+  });
+
+  it('rejects an excluded holder that overlaps an unclaimed additional allocation', async () => {
+    const svc = serviceWithSupply(TOTAL_RAW);
+
+    await expect(svc.getSupplyInfo(MINT, {
+      ...baseAllocation(),
+      additionalTokenAllocation: {
+        amount: new BN(25_000).mul(ONE),
+        recipient: HOLDER_A,
+        claimed: false,
+      },
+      excludedHolders: [
+        { address: HOLDER_A, amount: new BN(25_000).mul(ONE) },
+      ],
+    })).rejects.toThrow('overlaps the unclaimed additional-token allocation');
+  });
+
+  it('rejects an excluded holder that overlaps the DAO treasury owner', async () => {
+    const svc = serviceWithSupply(TOTAL_RAW);
+
+    await expect(svc.getSupplyInfo(MINT, {
+      ...baseAllocation(),
+      daoTreasuryTokens: {
+        amount: new BN(50_000).mul(ONE),
+        vaultAddress: HOLDER_A,
+      },
+      excludedHolders: [
+        { address: HOLDER_A, amount: new BN(50_000).mul(ONE) },
+      ],
+    })).rejects.toThrow('overlaps the DAO treasury allocation');
+  });
+
+  it('rejects overlap between named non-circulating allocation owners', async () => {
+    const svc = serviceWithSupply(TOTAL_RAW);
+
+    await expect(svc.getSupplyInfo(MINT, {
+      ...baseAllocation(),
+      teamPerformancePackage: {
+        amount: new BN(100_000).mul(ONE),
+        address: HOLDER_A,
+      },
+      daoTreasuryTokens: {
+        amount: new BN(50_000).mul(ONE),
+        vaultAddress: HOLDER_A,
+      },
+    })).rejects.toThrow(
+      'overlaps the team performance package and DAO treasury allocations',
+    );
+  });
+
+  it('rejects duplicate excluded-holder addresses', async () => {
+    const svc = serviceWithSupply(TOTAL_RAW);
+
+    await expect(svc.getSupplyInfo(MINT, {
+      ...baseAllocation(),
+      excludedHolders: [
+        { address: HOLDER_A, amount: new BN(10).mul(ONE) },
+        { address: HOLDER_A, amount: new BN(20).mul(ONE) },
+      ],
+    })).rejects.toThrow('configured more than once');
+  });
+
+  it('rejects non-circulating allocations that exceed total supply', async () => {
+    const svc = serviceWithSupply(TOTAL_RAW);
+
+    await expect(svc.getSupplyInfo(MINT, {
+      ...baseAllocation(),
+      excludedHolders: [
+        { address: HOLDER_A, amount: new BN(2_000_000).mul(ONE) },
+      ],
+    })).rejects.toThrow('Non-circulating allocations exceed total supply');
+  });
+
+  it('bounds cached snapshot variants and evicts the oldest entry', () => {
+    const svc = new SolanaService();
+
+    for (let index = 0; index <= 1000; index++) {
+      (svc as any).setCache(`snapshot-${index}`, index);
+    }
+
+    expect((svc as any).cache.size).toBe(1000);
+    expect((svc as any).cache.has('snapshot-0')).toBe(false);
+    expect((svc as any).cache.get('snapshot-1000')?.data).toBe(1000);
+  });
+});