sneak
d7f0e241ff
Out of the box the wallet sent the user's addresses to Blockscout for history and token lookups, and each recipient to Etherscan for its label. Two settings, "Use Blockscout" and "Check recipients on Etherscan", now gate those requests where they are made. Both are off in a new profile and offered unticked on Welcome and in Settings. While one is off, the screens that relied on it say so in a plain line naming the setting; after either changes in Settings, Back draws the screen it lands on again. ENS lookups ask only the RPC endpoint, so a name resolved off-chain does not resolve. README and the user guide say what is contacted by default and what each setting adds. Model: opus-5-5
305 lines
10 KiB
JavaScript
305 lines
10 KiB
JavaScript
// The balance of each token the user tracks is read with balanceOf through the
|
|
// RPC endpoint, for every address. Blockscout's answer gives a tracked token its
|
|
// holder count and decimals, and adds the tokens the user has not tracked
|
|
// (https://git.eeqj.de/sneak/AutistMask/issues/669).
|
|
//
|
|
// The real refreshBalances() runs against a fake JSON-RPC node, answered
|
|
// through ethers' own request hook, and a fake Blockscout, answered through
|
|
// fetch().
|
|
|
|
const { AbiCoder, FetchRequest } = require("ethers");
|
|
const { refreshBalances } = require("../src/shared/balances");
|
|
|
|
const RPC_URL = "https://rpc.example.invalid";
|
|
const EXPLORER_URL = "https://explorer.example.invalid/api/v2";
|
|
const FIRST = "0x1111111111111111111111111111111111111111";
|
|
const SECOND = "0x2222222222222222222222222222222222222222";
|
|
|
|
// A token the user tracks, outside the bundled list, at 6 decimals.
|
|
const TOKEN = "0x7777777777777777777777777777777777777777";
|
|
const TRACKED = {
|
|
address: TOKEN,
|
|
symbol: "TRK",
|
|
name: "Tracked Token",
|
|
decimals: 6,
|
|
};
|
|
|
|
// USDC, from the bundled list, which the user does not track.
|
|
const USDC = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48";
|
|
// Neither on the bundled list nor tracked.
|
|
const OTHER = "0x8888888888888888888888888888888888888888";
|
|
|
|
const ZERO_WORD = "0x" + "0".repeat(64);
|
|
const BALANCE_OF = "0x70a08231";
|
|
|
|
// What balanceOf answers, by token contract and then by holder. A pair that is
|
|
// not here makes balanceOf fail.
|
|
let holdings;
|
|
// What Blockscout answers for every address; null makes the request fail.
|
|
let explorerRows;
|
|
let logged;
|
|
|
|
// One JSON-RPC answer. A call that is not balanceOf is the ENS reverse lookup,
|
|
// answered with no resolver, so no name.
|
|
function reply(req) {
|
|
const envelope = { jsonrpc: "2.0", id: req.id };
|
|
if (req.method === "eth_getBalance") {
|
|
return { ...envelope, result: "0x0" };
|
|
}
|
|
if (req.method !== "eth_call") {
|
|
return {
|
|
...envelope,
|
|
error: { code: -32601, message: "method not found" },
|
|
};
|
|
}
|
|
const { to, data } = req.params[0];
|
|
if (!data.startsWith(BALANCE_OF)) return { ...envelope, result: ZERO_WORD };
|
|
const holder = "0x" + data.slice(-40);
|
|
const amount = (holdings[to.toLowerCase()] || {})[holder];
|
|
if (amount === undefined) {
|
|
return {
|
|
...envelope,
|
|
error: { code: -32000, message: "fixture: balanceOf failed" },
|
|
};
|
|
}
|
|
return {
|
|
...envelope,
|
|
result: AbiCoder.defaultAbiCoder().encode(["uint256"], [amount]),
|
|
};
|
|
}
|
|
|
|
const realFetch = globalThis.fetch;
|
|
|
|
beforeEach(() => {
|
|
holdings = {};
|
|
explorerRows = null;
|
|
logged = [];
|
|
jest.spyOn(console, "error").mockImplementation((...args) => {
|
|
logged.push(args.map(String).join(" "));
|
|
});
|
|
FetchRequest.registerGetUrl(async (req) => {
|
|
const body = JSON.parse(Buffer.from(req.body).toString("utf8"));
|
|
const answer = Array.isArray(body) ? body.map(reply) : reply(body);
|
|
return {
|
|
statusCode: 200,
|
|
statusMessage: "OK",
|
|
headers: { "content-type": "application/json" },
|
|
body: Buffer.from(JSON.stringify(answer)),
|
|
};
|
|
});
|
|
globalThis.fetch = jest.fn(async () => {
|
|
if (explorerRows === null) throw new TypeError("Failed to fetch");
|
|
return { ok: true, status: 200, json: async () => explorerRows };
|
|
});
|
|
});
|
|
|
|
afterEach(() => {
|
|
FetchRequest.registerGetUrl(FetchRequest.createGetUrlFunc());
|
|
globalThis.fetch = realFetch;
|
|
jest.restoreAllMocks();
|
|
});
|
|
|
|
// One Blockscout token-balances row.
|
|
function explorerRow(address, symbol, value, holders = "50000") {
|
|
return {
|
|
value: String(value),
|
|
token: {
|
|
type: "ERC-20",
|
|
address_hash: address,
|
|
symbol: symbol,
|
|
name: symbol,
|
|
decimals: "6",
|
|
holders_count: holders,
|
|
},
|
|
};
|
|
}
|
|
|
|
// The row refreshBalances() writes for TOKEN from a balanceOf answer, with the
|
|
// decimals and holder count Blockscout reported for it, if any.
|
|
function trackedRow(balance, decimals = null, holders = null) {
|
|
return {
|
|
address: TOKEN,
|
|
name: "Tracked Token",
|
|
symbol: "TRK",
|
|
decimals: decimals,
|
|
balance: balance,
|
|
holders: holders,
|
|
};
|
|
}
|
|
|
|
async function refresh(addresses, trackedTokens) {
|
|
await refreshBalances(
|
|
[{ addresses }],
|
|
RPC_URL,
|
|
EXPLORER_URL,
|
|
true,
|
|
trackedTokens,
|
|
"mainnet",
|
|
new AbortController().signal,
|
|
);
|
|
return addresses;
|
|
}
|
|
|
|
test("with Blockscout failing, a tracked token's balance is read through the RPC endpoint for every address", async () => {
|
|
holdings[TOKEN] = { [FIRST]: 1234500000n, [SECOND]: 1n };
|
|
const [first, second] = await refresh(
|
|
[
|
|
{ address: FIRST, tokenBalances: [] },
|
|
{ address: SECOND, tokenBalances: [] },
|
|
],
|
|
[TRACKED],
|
|
);
|
|
expect(first.tokenBalances).toEqual([trackedRow("1234.5")]);
|
|
// Exact, never cut: one base unit is not zero.
|
|
expect(second.tokenBalances).toEqual([trackedRow("0.000001")]);
|
|
});
|
|
|
|
test("with Blockscout failing, the untracked rows from before stay", async () => {
|
|
holdings[TOKEN] = { [FIRST]: 2000000n };
|
|
const usdc = {
|
|
address: USDC,
|
|
name: "USD Coin",
|
|
symbol: "USDC",
|
|
decimals: 6,
|
|
balance: "5.0",
|
|
holders: 50000,
|
|
};
|
|
const [first] = await refresh(
|
|
[{ address: FIRST, tokenBalances: [usdc] }],
|
|
[TRACKED],
|
|
);
|
|
expect(first.tokenBalances).toEqual([trackedRow("2.0"), usdc]);
|
|
});
|
|
|
|
test("a tracked token Blockscout also reports shows the RPC figure, and an untracked one is admitted as before", async () => {
|
|
holdings[TOKEN] = { [FIRST]: 2000000n };
|
|
explorerRows = [
|
|
explorerRow(TOKEN, "TRK", 9000000),
|
|
explorerRow(USDC, "USDC", 5000000),
|
|
// Too few holders, and neither on the bundled list nor tracked.
|
|
explorerRow(OTHER, "SPAM", 5000000, "10"),
|
|
// A known symbol from a contract it does not belong to.
|
|
explorerRow(OTHER, "USDC", 5000000),
|
|
];
|
|
const [first] = await refresh(
|
|
[{ address: FIRST, tokenBalances: [] }],
|
|
[TRACKED],
|
|
);
|
|
expect(first.tokenBalances).toEqual([
|
|
trackedRow("2.0", 6, 50000),
|
|
{
|
|
address: USDC,
|
|
name: "USDC",
|
|
symbol: "USDC",
|
|
decimals: 6,
|
|
balance: "5.0",
|
|
holders: 50000,
|
|
},
|
|
]);
|
|
});
|
|
|
|
test("a tracked token's entry carries the holder count and decimals Blockscout reports for it", async () => {
|
|
holdings[TOKEN] = { [FIRST]: 2000000n };
|
|
// Fewer holders than "Hide tokens with fewer than 1,000 holders" lets
|
|
// through to Send's token list.
|
|
explorerRows = [explorerRow(TOKEN, "TRK", 9000000, "10")];
|
|
const [first] = await refresh(
|
|
[{ address: FIRST, tokenBalances: [] }],
|
|
[TRACKED],
|
|
);
|
|
expect(first.tokenBalances).toEqual([trackedRow("2.0", 6, 10)]);
|
|
});
|
|
|
|
test("while Blockscout fails, a tracked token keeps the holder count and decimals of its entry from before", async () => {
|
|
holdings[TOKEN] = { [FIRST]: 2000000n };
|
|
const [first] = await refresh(
|
|
[{ address: FIRST, tokenBalances: [trackedRow("7.0", 6, 10)] }],
|
|
[TRACKED],
|
|
);
|
|
expect(first.tokenBalances).toEqual([trackedRow("2.0", 6, 10)]);
|
|
});
|
|
|
|
test("a failed balanceOf keeps the token's entry from before, and is logged", async () => {
|
|
explorerRows = [explorerRow(TOKEN, "TRK", 9000000)];
|
|
const before = trackedRow("7.0", 6, 50000);
|
|
const [first] = await refresh(
|
|
[{ address: FIRST, tokenBalances: [before] }],
|
|
[TRACKED],
|
|
);
|
|
expect(first.tokenBalances).toEqual([before]);
|
|
expect(logged.some((line) => line.includes("token balance failed"))).toBe(
|
|
true,
|
|
);
|
|
});
|
|
|
|
test("a failed balanceOf with no entry from before takes Blockscout's entry from this refresh", async () => {
|
|
// balanceOf fails at FIRST and answers at SECOND.
|
|
holdings[TOKEN] = { [SECOND]: 2000000n };
|
|
explorerRows = [explorerRow(TOKEN, "TRK", 9000000)];
|
|
const [first, second] = await refresh(
|
|
[
|
|
{ address: FIRST, tokenBalances: [] },
|
|
{ address: SECOND, tokenBalances: [] },
|
|
],
|
|
[TRACKED],
|
|
);
|
|
expect(first.tokenBalances).toEqual([
|
|
{
|
|
address: TOKEN,
|
|
name: "TRK",
|
|
symbol: "TRK",
|
|
decimals: 6,
|
|
balance: "9.0",
|
|
holders: 50000,
|
|
},
|
|
]);
|
|
// Where balanceOf answers, its figure stands.
|
|
expect(second.tokenBalances).toEqual([trackedRow("2.0", 6, 50000)]);
|
|
});
|
|
|
|
test("a balance of zero read through the RPC endpoint replaces the previous figure", async () => {
|
|
holdings[TOKEN] = { [FIRST]: 0n };
|
|
const [first] = await refresh(
|
|
[{ address: FIRST, tokenBalances: [trackedRow("7.0")] }],
|
|
[TRACKED],
|
|
);
|
|
expect(first.tokenBalances).toEqual([]);
|
|
});
|
|
|
|
test("a tracked token whose scale nothing knows gets no quantity, not a zero", async () => {
|
|
holdings[TOKEN] = { [FIRST]: 5n };
|
|
const [first] = await refresh(
|
|
[{ address: FIRST, tokenBalances: [] }],
|
|
[{ ...TRACKED, decimals: null }],
|
|
);
|
|
expect(first.tokenBalances).toEqual([trackedRow(null)]);
|
|
});
|
|
|
|
test("a tracked token whose scale only Blockscout reports is stated at that scale", async () => {
|
|
holdings[TOKEN] = { [FIRST]: 2000000n };
|
|
explorerRows = [explorerRow(TOKEN, "TRK", 9000000)];
|
|
const [first] = await refresh(
|
|
[{ address: FIRST, tokenBalances: [] }],
|
|
[{ ...TRACKED, decimals: null }],
|
|
);
|
|
expect(first.tokenBalances).toEqual([trackedRow("2.0", 6, 50000)]);
|
|
});
|
|
|
|
test("a tracked token wearing a known symbol from another contract is not listed", async () => {
|
|
holdings[OTHER] = { [FIRST]: 5000000n };
|
|
// Its entry from before goes too, although Blockscout fails.
|
|
const before = {
|
|
address: OTHER,
|
|
name: "Fake",
|
|
symbol: "USDC",
|
|
decimals: 6,
|
|
balance: "5.0",
|
|
holders: 50000,
|
|
};
|
|
const [first] = await refresh(
|
|
[{ address: FIRST, tokenBalances: [before] }],
|
|
[{ address: OTHER, symbol: "USDC", name: "Fake", decimals: 6 }],
|
|
);
|
|
expect(first.tokenBalances).toEqual([]);
|
|
});
|