fix: a tracked token reads quantity unknown at an address no refresh has read (closes #720)

A new address, a new wallet and a network switch each leave tracked tokens
with no balance entry, so their lines read 0.0000 before any refresh had read
them.

Each of these now sets `balanceNotFetched` on the tracked tokens, and a refresh
already clears it. Their lines read `quantity unknown` until then. Addresses
that the wallet scan finds get the same.

Model: opus-5-5

tests/addedTokenBalance.test.js

@@ -11,14 +11,44 @@
 // switch keeps each network's records apart. A refresh takes the field off the
 // stored record's tokens and keeps another page's changes to the stored list.
 //
+// Every tracked token carries that field again once an address or a wallet is
+// added, and after a network switch, so it reads the same until a refresh has
+// read it (https://git.eeqj.de/sneak/AutistMask/issues/720).
+//
 // Driven through the real popup over a stored profile on Ethereum Mainnet,
 // with "Show tracked tokens with zero balance" on, as it is by default.
 
+const { HDNodeWallet, Mnemonic } = require("ethers");
+
 const {
     bootPopup,
     cleanupPopup,
     unversionedValidProfile,
 } = require("./support/popupBoot");
+const { hdWalletFromMnemonic } = require("../src/shared/wallet");
+
+const PHRASE =
+    "abandon abandon abandon abandon abandon abandon " +
+    "abandon abandon abandon abandon abandon about";
+const PASSWORD = "correct horse battery staple";
+
+// What AddWallet's tabs take. The first and last scan for more addresses.
+const FROM_PHRASE = {
+    tab: "tab-mnemonic",
+    field: "wallet-mnemonic",
+    secret: PHRASE,
+};
+const FROM_PRIVATE_KEY = {
+    tab: "tab-privkey",
+    field: "import-private-key",
+    secret: "0x" + "11".repeat(32),
+};
+const FROM_XPRV = {
+    tab: "tab-xprv",
+    field: "import-xprv-key",
+    secret: HDNodeWallet.fromSeed(Mnemonic.fromPhrase(PHRASE).computeSeed())
+        .extendedKey,
+};
 
 // Tracked by nobody until a test adds it.
 const NEW_TOKEN = "0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB";
@@ -175,6 +205,47 @@ function newTokenRow(page, id = "address-balances") {
         );
 }
 
+// Every address's row for NEW_TOKEN on Home, as markup, in the order Home lists
+// the addresses.
+function newTokenRowsOnHome(page) {
+    return page
+        .node("wallet-list")
+        .innerHTML.split("<div ")
+        .filter((row) =>
+            row.includes('data-token="' + NEW_TOKEN.toLowerCase() + '"'),
+        );
+}
+
+// The "+" button Home draws for the first wallet. As in firstRemoveButton(),
+// the list hands Home a stand-in for that button each time it is drawn, and
+// `press()` presses the last one drawn. Call it before Home next draws its list.
+function plusButton(page) {
+    const button = { press: null };
+    page.node("wallet-list").querySelectorAll = (selector) =>
+        selector !== ".btn-add-address"
+            ? []
+            : [
+                  {
+                      dataset: { wallet: "0" },
+                      addEventListener: (name, fn) => {
+                          button.press = () =>
+                              fn({ stopPropagation: () => {} });
+                      },
+                  },
+              ];
+    return button;
+}
+
+// "Add wallet" on Home, filled in from `source`, and "Import".
+async function addWallet(page, { tab, field, secret }) {
+    await page.click("btn-add-wallet-bottom");
+    await page.click(tab);
+    page.node(field).value = secret;
+    page.node("add-wallet-password").value = PASSWORD;
+    page.node("add-wallet-password-confirm").value = PASSWORD;
+    await page.click("btn-add-wallet-confirm");
+}
+
 // AddressDetail for the one address opened from Home, as its `[info]` button
 // does.
 async function openAddress(page) {
@@ -456,3 +527,143 @@ test("a refresh does not bring back a token that another page removed after this
         NEW_TRACKED,
     ]);
 });
+
+test("an address just added reads quantity unknown for a tracked token until a refresh has read it", async () => {
+    const { xpub, firstAddress } = hdWalletFromMnemonic(PHRASE);
+    const page = await bootPopup(
+        unversionedValidProfile({
+            wallets: [
+                {
+                    type: "hd",
+                    name: "Wallet 1",
+                    xpub,
+                    encryptedSecret: "encrypted-secret-1",
+                    nextIndex: 1,
+                    addresses: [
+                        {
+                            address: firstAddress,
+                            balance: "1.5",
+                            tokenBalances: [MILLION],
+                        },
+                    ],
+                },
+            ],
+            activeAddress: firstAddress,
+            trackedTokens: [NEW_TRACKED],
+        }),
+    );
+    const plus = plusButton(page);
+    await refreshOnce(page, [MILLION]);
+    const finish = holdNextRefresh(page);
+
+    await plus.press();
+    await page.settle();
+
+    const [held, added] = newTokenRowsOnHome(page);
+    expect(held).toContain("1000000.0000");
+    expect(added).toContain("quantity unknown");
+    expect(added).not.toContain("0.0000");
+    expect(
+        page.storage.read("autistmask").trackedTokens[0].balanceNotFetched,
+    ).toBe(true);
+
+    // It reads the new address's balance, which is zero.
+    await finish([MILLION]);
+
+    expect(newTokenRowsOnHome(page)[1]).toContain("0.0000");
+});
+
+test.each([FROM_PHRASE, FROM_PRIVATE_KEY, FROM_XPRV])(
+    "a wallet just added from $tab reads quantity unknown for a tracked token until a refresh has read it",
+    async (source) => {
+        const page = await bootPopup(
+            unversionedValidProfile({ trackedTokens: [NEW_TRACKED] }),
+        );
+        const finish = holdNextRefresh(page);
+
+        await addWallet(page, source);
+
+        const added = newTokenRowsOnHome(page)[1];
+        expect(added).toContain("quantity unknown");
+        expect(added).not.toContain("0.0000");
+
+        // It reads the new address's balance, which is zero.
+        await finish([]);
+
+        expect(newTokenRowsOnHome(page)[1]).toContain("0.0000");
+    },
+);
+
+test.each([FROM_PHRASE, FROM_XPRV])(
+    "addresses the scan finds for a wallet from $tab read quantity unknown, even after a refresh returned during the scan",
+    async (source) => {
+        const page = await bootPopup(
+            unversionedValidProfile({ trackedTokens: [NEW_TRACKED] }),
+        );
+        const { scanForAddresses } = require("../src/shared/balances");
+        let finish;
+        scanForAddresses.mockImplementationOnce(async () => {
+            await refreshOnce(page, []);
+            finish = holdNextRefresh(page);
+            return {
+                addresses: [
+                    { address: "0x" + "dd".repeat(20), index: 0 },
+                    { address: "0x" + "ee".repeat(20), index: 1 },
+                ],
+                nextIndex: 2,
+            };
+        });
+
+        await addWallet(page, source);
+
+        const [, first, second] = newTokenRowsOnHome(page);
+        for (const found of [first, second]) {
+            expect(found).toContain("quantity unknown");
+            expect(found).not.toContain("0.0000");
+        }
+
+        await finish([]);
+
+        expect(newTokenRowsOnHome(page)[2]).toContain("0.0000");
+    },
+);
+
+test("after a network switch in Settings, a tracked token reads quantity unknown until a refresh has read it", async () => {
+    const page = await bootOnAddress({
+        trackedTokens: [OTHER_TOKEN],
+        networkTrackedTokens: { sepolia: [NEW_TRACKED] },
+    });
+
+    await page.click("btn-settings");
+    await chooseNetwork(page, "sepolia");
+    await page.click("btn-settings-back");
+
+    expect(page.visibleViews()).toEqual(["address"]);
+    const row = newTokenRow(page);
+    expect(row).toContain("quantity unknown");
+    expect(row).not.toContain("0.0000");
+
+    // It reads the balance, which is zero.
+    await refreshOnce(page, []);
+
+    expect(newTokenRow(page)).toContain("0.0000");
+});
+
+test("after a switch saved by the background, a tracked token reads quantity unknown until a refresh has read it", async () => {
+    const page = await bootOnAddress({
+        networkTrackedTokens: { sepolia: [NEW_TRACKED] },
+    });
+    const {
+        applyChainSwitchFields,
+    } = require("../src/shared/chainSwitchFields");
+    const record = page.storage.read("autistmask");
+    applyChainSwitchFields(record, "sepolia");
+    page.storage.write("autistmask", record);
+
+    // The popup takes the switch, and this refresh reads no token's balance.
+    await page.tick();
+
+    const row = newTokenRow(page);
+    expect(row).toContain("quantity unknown");
+    expect(row).not.toContain("0.0000");
+});

tests/addressScanCancelled.test.js

@@ -44,6 +44,7 @@ jest.doMock("../src/popup/views/helpers", () => ({
     goBack: () => {},
     clearViewStack: () => {},
     onViewLeave: () => {},
+    markTrackedTokensNotFetched: () => {},
 }));
 
 // state.js reads chrome.storage.local at load, and saveState() writes it.

tests/coldWorkerChainSwitch.test.js

@@ -242,7 +242,12 @@ describe("a chain switch on a worker that never loaded state", () => {
         expect(bg.persisted().blockscoutUrl).toBe(CUSTOM_BLOCKSCOUT);
         expect(bg.persisted().wallets).toEqual(walletFixture());
         expect(bg.persisted().trackedTokens).toEqual([
-            { address: TOKEN, symbol: "DAI", decimals: 18 },
+            {
+                address: TOKEN,
+                symbol: "DAI",
+                decimals: 18,
+                balanceNotFetched: true,
+            },
         ]);
     });
 

tests/popupFollowsNetworkSwitch.test.js

@@ -245,7 +245,9 @@ test("a switch back in Settings after a follow whose write failed is stored", as
     const stored = page.storage.read("autistmask");
     expect(stored.networkId).toBe("mainnet");
     expect(stored.rpcUrl).toBe(NETWORKS.mainnet.defaultRpcUrl);
-    expect(stored.trackedTokens).toEqual([MAINNET_TOKEN]);
+    expect(stored.trackedTokens).toEqual([
+        { ...MAINNET_TOKEN, balanceNotFetched: true },
+    ]);
     expect(page.text("flash-msg")).toBe("Switched to Ethereum Mainnet.");
     const told = globalThis.chrome.runtime.sendMessage.mock.calls
         .map(([message]) => message)

tests/trackedTokensPerNetwork.test.js

@@ -180,7 +180,10 @@ test("a token added by contract address on Sepolia is tracked on Sepolia only",
     await boot.click("btn-settings");
     await chooseNetwork(boot, "mainnet");
     expect(stored().networkId).toBe("mainnet");
-    expect(stored().trackedTokens).toEqual([MAINNET_TOKEN]);
+    // No refresh has read a balance on this network since the switch.
+    expect(stored().trackedTokens).toEqual([
+        { ...MAINNET_TOKEN, balanceNotFetched: true },
+    ]);
     const onMainnet = boot.node("settings-tracked-tokens").innerHTML;
     expect(onMainnet).toContain("DAI");
     expect(onMainnet).not.toContain("TST");
@@ -276,7 +279,9 @@ test("a token tracked on Sepolia when another page switched there is not tracked
 
     const stored = boot.storage.read("autistmask");
     expect(stored.networkId).toBe("sepolia");
-    expect(stored.trackedTokens).toEqual([SEPOLIA_TOKEN]);
+    expect(stored.trackedTokens).toEqual([
+        { ...SEPOLIA_TOKEN, balanceNotFetched: true },
+    ]);
     expect(stored.networkTrackedTokens.mainnet).toEqual([]);
 });
 
@@ -441,7 +446,10 @@ test("a token another page added on Ethereum Mainnet is tracked when this page s
 
     const stored = boot.storage.read("autistmask");
     expect(stored.networkId).toBe("mainnet");
-    expect(stored.trackedTokens).toEqual([MAINNET_TOKEN, newToken]);
+    expect(stored.trackedTokens).toEqual([
+        { ...MAINNET_TOKEN, balanceNotFetched: true },
+        { ...newToken, balanceNotFetched: true },
+    ]);
 });
 
 // This page tracks DAI on Ethereum Mainnet and switches to Sepolia. Another
@@ -489,7 +497,10 @@ test("a token another page added on Ethereum Mainnet stays when this page adds a
     const stored = boot.storage.read("autistmask");
     expect(stored.networkTrackedTokens.mainnet).toEqual([MAINNET_TOKEN]);
     expect(stored.networkTrackedTokens.sepolia).toEqual([SEPOLIA_TOKEN]);
-    expect(stored.trackedTokens).toEqual([SEPOLIA_TOKEN, added]);
+    expect(stored.trackedTokens).toEqual([
+        { ...SEPOLIA_TOKEN, balanceNotFetched: true },
+        added,
+    ]);
 });
 
 // This page tracks DAI on Ethereum Mainnet and switches to Sepolia, where TST is
@@ -513,7 +524,10 @@ test("a token another page removed on Ethereum Mainnet stays removed when this p
     const stored = boot.storage.read("autistmask");
     expect(stored.networkTrackedTokens.mainnet).toEqual([]);
     expect(stored.networkTrackedTokens.sepolia).toEqual([SEPOLIA_TOKEN]);
-    expect(stored.trackedTokens).toEqual([SEPOLIA_TOKEN, added]);
+    expect(stored.trackedTokens).toEqual([
+        { ...SEPOLIA_TOKEN, balanceNotFetched: true },
+        added,
+    ]);
 });
 
 // Another popup page records a fraud contract on Ethereum Mainnet after this
@@ -1031,7 +1045,9 @@ describe("a contract lookup that answers after a switch adds nothing", () => {
         await addAcrossSwitch(boot, "btn-settings-addtoken-manual", "mainnet");
         expect(boot.visibleViews()).toEqual(["settings"]);
         expect(boot.text("flash-msg")).toBe(NETWORK_CHANGED_FLASH);
-        expect(stored().trackedTokens).toEqual([MAINNET_TOKEN]);
+        expect(stored().trackedTokens).toEqual([
+            { ...MAINNET_TOKEN, balanceNotFetched: true },
+        ]);
         expect(stored().networkTrackedTokens.sepolia).toEqual([]);
     });
 
@@ -1044,7 +1060,9 @@ describe("a contract lookup that answers after a switch adds nothing", () => {
         await addAcrossSwitch(boot, "btn-add-token-confirm", "sepolia");
         expect(boot.visibleViews()).toEqual(["settings"]);
         expect(boot.text("flash-msg")).toBe(NETWORK_CHANGED_FLASH);
-        expect(stored().trackedTokens).toEqual([SEPOLIA_TOKEN]);
+        expect(stored().trackedTokens).toEqual([
+            { ...SEPOLIA_TOKEN, balanceNotFetched: true },
+        ]);
         expect(stored().networkTrackedTokens.mainnet).toEqual([MAINNET_TOKEN]);
     });
 });