fix: distinguish an unknown holder count from zero so a legitimate token is not filtered (closes #230)

src/popup/views/send.js

@@ -13,6 +13,7 @@ const { state, currentAddress } = require("../../shared/state");
 let ctx;
 const { getProvider } = require("../../shared/balances");
 const { KNOWN_SYMBOLS, resolveSymbol } = require("../../shared/tokenList");
+const { isLowHolderCount } = require("../../shared/holders");
 const { getAddress } = require("ethers");
 
 const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
@@ -132,7 +133,10 @@ function renderSendTokenSelect(addr) {
     for (const t of addr.tokenBalances || []) {
         if (isSpoofedToken(t)) continue;
         if (fraudSet.has(t.address.toLowerCase())) continue;
-        if (state.hideLowHolderTokens && (t.holders || 0) < 1000) continue;
+        // An unknown holder count does not withhold a token the user holds:
+        // only a count the explorer actually reported as below the threshold
+        // does.  Otherwise a missing field makes a real asset unspendable.
+        if (state.hideLowHolderTokens && isLowHolderCount(t.holders)) continue;
         const opt = document.createElement("option");
         opt.value = t.address;
         opt.textContent = t.symbol;

src/shared/balances.js

@@ -12,6 +12,7 @@ const { ERC20_ABI } = require("./constants");
 const { log, debugFetch } = require("./log");
 const { deriveAddressFromXpub } = require("./wallet");
 const { KNOWN_SYMBOLS, TOKEN_BY_ADDRESS } = require("./tokenList");
+const { LOW_HOLDER_THRESHOLD, parseHoldersCount } = require("./holders");
 
 // Use a static network to skip auto-detection (which can fail and cause
 // "could not coalesce error" on some RPC endpoints like Cloudflare).
@@ -70,10 +71,20 @@ async function fetchTokenBalances(address, blockscoutUrl, trackedTokens) {
             if (bal === "0.0") continue;
 
             const tokenAddr = (item.token.address_hash || "").toLowerCase();
-            const holders = parseInt(item.token.holders_count || "0", 10);
+            // null means the explorer reported no count, which is not the
+            // same as a count of zero.  This gate is not the low-holder
+            // display filter: it has no user-facing off switch and governs
+            // the whole balance list, so it stays strict and admits a token
+            // only on a reported count — an unreported one is no evidence.
+            // A legitimate token still reaches the list through the known
+            // token list or by the user tracking it, and the null is carried
+            // through to the views, where the two low-holder filters treat
+            // an unknown count as "do not judge" rather than as zero.
+            const holders = parseHoldersCount(item.token.holders_count);
             const isKnown = TOKEN_BY_ADDRESS.has(tokenAddr);
             const isTracked = trackedSet.has(tokenAddr);
-            const hasEnoughHolders = holders >= 1000;
+            const hasEnoughHolders =
+                holders !== null && holders >= LOW_HOLDER_THRESHOLD;
 
             // Skip spam tokens the user never asked to see
             if (!isKnown && !isTracked && !hasEnoughHolders) continue;
@@ -278,6 +289,7 @@ async function scanForAddresses(xpub, rpcUrl, gapLimit = 5) {
 }
 
 module.exports = {
+    fetchTokenBalances,
     refreshBalances,
     lookupTokenInfo,
     getProvider,

src/shared/holders.js

@@ -0,0 +1,32 @@
+// Holder counts, and the one rule that decides whether a count is "low".
+//
+// The block explorer's holders_count is optional: it is absent on a token it
+// has only just indexed, and it goes missing on a degraded or changed API.
+// Absent means the count is unknown.  It does not mean the token has no
+// holders, and collapsing the two hides a token the user really holds as if
+// it were spam.  Every call site reads the count through here so the
+// distinction cannot be lost again in one place while holding in the others.
+
+const LOW_HOLDER_THRESHOLD = 1000;
+
+// Parse an explorer-supplied holders_count into a number, or null when the
+// explorer did not report one.  Anything unparseable is unknown too: a count
+// we cannot read is not a count of zero.
+function parseHoldersCount(raw) {
+    if (raw === null || raw === undefined || raw === "") return null;
+    const n = parseInt(raw, 10);
+    return Number.isFinite(n) ? n : null;
+}
+
+// True only for a token the explorer reported as having fewer holders than
+// the threshold.  An unknown count is never low: showing a spam token the
+// user can see is unusual costs less than hiding an asset they own.
+function isLowHolderCount(holders) {
+    return holders != null && holders < LOW_HOLDER_THRESHOLD;
+}
+
+module.exports = {
+    LOW_HOLDER_THRESHOLD,
+    parseHoldersCount,
+    isLowHolderCount,
+};

src/shared/transactions.js

@@ -9,6 +9,7 @@
 const { formatEther, formatUnits } = require("ethers");
 const { log, debugFetch } = require("./log");
 const { KNOWN_SYMBOLS, TOKEN_BY_ADDRESS } = require("./tokenList");
+const { parseHoldersCount, isLowHolderCount } = require("./holders");
 
 // Ethereum addresses are case-insensitive: EIP-55 mixed case is a checksum
 // over the address, not part of its identity.  Every address comparison in
@@ -116,7 +117,10 @@ function parseTokenTransfer(tt, addrLower) {
         contractAddress: normalizeAddress(
             tt.token?.address_hash || tt.token?.address || "",
         ),
-        holders: parseInt(tt.token?.holders_count || "0", 10),
+        // null when the explorer reported no count: unknown, not zero.  The
+        // low-holder filter declines to judge a null, so a legitimate token
+        // is not hidden because a field went missing upstream.
+        holders: parseHoldersCount(tt.token?.holders_count),
     };
 }
 
@@ -292,12 +296,13 @@ function filterTransactions(txs, filters = {}) {
             continue;
         }
 
-        // Filter low-holder tokens (<1000) if setting is on
+        // Filter low-holder tokens (<1000) if setting is on.  A token whose
+        // holder count the explorer did not report is kept: only a reported
+        // count below the threshold is "low".
         if (
             filters.hideLowHolderTokens &&
             tx.contractAddress &&
-            tx.holders !== null &&
-            tx.holders < 1000
+            isLowHolderCount(tx.holders)
         ) {
             continue;
         }