fix: treat an unreported holders_count as unknown, not as zero holders (closes #230)

The block explorer's holders_count is optional. Reading it as
`holders_count || "0"` recorded a token the explorer said nothing about
as a token with no holders at all, which is the strongest spam signal the
wallet has: the low-holder rule then hid a legitimate transfer from the
history and withheld a token the user actually holds from the Send
selector. It also made the `tx.holders !== null` guard in
filterTransactions unreachable for token transfers, since the coercion
guaranteed a number.

The null-versus-zero rule and the 1,000-holder threshold now live in one
place, src/shared/holders.js, because the rule was open-coded at three
call sites and got it wrong at all three.

An unknown count is shown rather than hidden in both user-facing
filters: hiding an asset the user owns costs more than showing a spam row
they can see is unusual, and both filters have a setting behind them.
The balance-list spam gate in fetchTokenBalances keeps its strict
behaviour — it has no off switch and governs the whole balance list, so
an unreported count is no evidence for admission — but it now records the
unknown as null, so a token that reaches the list by being known or
tracked is no longer hidden downstream by a zero it never reported.

A reported count of zero still parses to 0 and is still filtered
everywhere; that is covered by tests alongside the unknown-count ones.

tests/sendTokenSelect.test.js

@@ -0,0 +1,123 @@
+// Tests for the token filtering in the Send view's token selector
+// (src/popup/views/send.js).
+//
+// The selector decides which of the user's tokens can be spent at all, so
+// over-filtering here is worse than in the history list: the asset is not
+// merely hidden, it becomes unspendable through the UI.  Issue #230: an
+// explorer that omits holders_count was read as "zero holders" and the token
+// disappeared from this list.
+//
+// renderSendTokenSelect only ever touches getElementById, createElement,
+// innerHTML, value, textContent and appendChild, so a small stub document is
+// enough to drive it; the real DOM behaviour of the view is covered by
+// tests/e2e/run.js.
+
+globalThis.chrome = {
+    storage: { local: { get: async () => ({}), set: async () => {} } },
+};
+
+const { state } = require("../src/shared/state");
+const { renderSendTokenSelect } = require("../src/popup/views/send");
+
+const USDC_CONTRACT = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
+const NOVEL_TOKEN = "0x1111111111111111111111111111111111111111";
+
+let select;
+
+function installStubDocument() {
+    select = { innerHTML: "", children: [] };
+    select.appendChild = (child) => select.children.push(child);
+    globalThis.document = {
+        getElementById: (id) => (id === "send-token" ? select : null),
+        createElement: () => ({ value: "", textContent: "" }),
+    };
+}
+
+// The symbols offered for sending, excluding the hardcoded ETH option that
+// renderSendTokenSelect writes straight into innerHTML.
+function offeredTokens() {
+    return select.children.map((opt) => opt.value.toLowerCase());
+}
+
+function tokenBalance(overrides) {
+    return {
+        address: NOVEL_TOKEN,
+        symbol: "SPAMTKN",
+        decimals: 18,
+        balance: "12.5",
+        holders: 50000,
+        ...overrides,
+    };
+}
+
+function render(tokenBalances) {
+    installStubDocument();
+    renderSendTokenSelect({ address: "0x" + "a".repeat(40), tokenBalances });
+}
+
+beforeEach(() => {
+    state.fraudContracts = [];
+    state.hideLowHolderTokens = true;
+});
+
+describe("the low-holder rule in the send token selector", () => {
+    test("ETH is always offered", () => {
+        render([]);
+        expect(select.innerHTML).toBe('<option value="ETH">ETH</option>');
+        expect(offeredTokens()).toEqual([]);
+    });
+
+    test("a token with plenty of holders is offered", () => {
+        render([tokenBalance()]);
+        expect(offeredTokens()).toEqual([NOVEL_TOKEN]);
+    });
+
+    test("a token reporting zero holders is withheld", () => {
+        render([tokenBalance({ holders: 0 })]);
+        expect(offeredTokens()).toEqual([]);
+    });
+
+    test("boundary: 999 holders is withheld, 1000 is offered", () => {
+        render([tokenBalance({ holders: 999 })]);
+        expect(offeredTokens()).toEqual([]);
+        render([tokenBalance({ holders: 1000 })]);
+        expect(offeredTokens()).toEqual([NOVEL_TOKEN]);
+    });
+
+    // Issue #230: an unknown holder count must not read as zero.  A token the
+    // user demonstrably holds — it has a balance — cannot be made unspendable
+    // by a field the block explorer failed to report.
+    test("a token whose holder count is unknown is still offered", () => {
+        render([tokenBalance({ holders: null })]);
+        expect(offeredTokens()).toEqual([NOVEL_TOKEN]);
+    });
+
+    test("a token balance carrying no holders field at all is offered", () => {
+        const t = tokenBalance();
+        delete t.holders;
+        render([t]);
+        expect(offeredTokens()).toEqual([NOVEL_TOKEN]);
+    });
+
+    test("the rule is bypassed entirely when the setting is off", () => {
+        state.hideLowHolderTokens = false;
+        render([tokenBalance({ holders: 0 })]);
+        expect(offeredTokens()).toEqual([NOVEL_TOKEN]);
+    });
+});
+
+describe("the other send-selector rules are unaffected", () => {
+    test("a token spoofing a known symbol from a wrong address is withheld", () => {
+        render([
+            tokenBalance({ symbol: "USDC", holders: null }),
+            tokenBalance({ address: USDC_CONTRACT, symbol: "USDC" }),
+        ]);
+        expect(offeredTokens()).toEqual([USDC_CONTRACT.toLowerCase()]);
+    });
+
+    test("a blocklisted fraud contract is withheld even with an unknown count", () => {
+        state.fraudContracts = [NOVEL_TOKEN.toUpperCase()];
+        render([tokenBalance({ holders: null })]);
+        expect(offeredTokens()).toEqual([]);
+    });
+});