Compare commits
1
Commits
next
..
88cee51f5e
| Author | SHA1 | Date | |
|---|---|---|---|
 sneak
|
88cee51f5e |
@@ -10,7 +10,6 @@ WORKDIR /app
|
||||
|
||||
COPY script/ script/
|
||||
COPY package.json yarn.lock ./
|
||||
# yarn warns about the workspaces field in eslint and babel-plugin-istanbul; no newer release drops it.
|
||||
RUN script/bootstrap
|
||||
|
||||
COPY . .
|
||||
|
||||
+392
-644
File diff suppressed because it is too large
Load Diff
+75
-213
@@ -1,225 +1,87 @@
|
||||
# Releasing AutistMask
|
||||
|
||||
A release is a tagged commit on the `main` branch and the two archives that
|
||||
`make package` writes from that commit. This file is the procedure, in order.
|
||||
This is the procedure that turns a green `main` into a tagged, packaged release.
|
||||
It gathers into one place what is otherwise spread across the `Makefile` and
|
||||
three `README.md` sections, so the person cutting a release does not have to
|
||||
reconstruct the order from them.
|
||||
|
||||
Only the owner ([@sneak](https://sneak.berlin)):
|
||||
|
||||
- decides whether and when a release is tagged;
|
||||
- creates, moves or deletes a tag;
|
||||
- decides where the archives are published.
|
||||
|
||||
Anyone can run steps 1 to 4. No script in this repository uploads or publishes
|
||||
the archives. None signs them, and none packs a CRX (Chrome's packaged extension
|
||||
file).
|
||||
|
||||
## Terms
|
||||
|
||||
- The tracker is the repository's Gitea site (Gitea is the software that hosts
|
||||
the repository): https://git.eeqj.de/sneak/AutistMask. The tracker's Actions
|
||||
page, https://git.eeqj.de/sneak/AutistMask/actions, lists the workflow runs.
|
||||
- A workflow is a file under `.gitea/workflows/` that lists jobs. The tracker
|
||||
runs every workflow on each push. Each job runs one script on the tracker's
|
||||
runner (the machine that runs jobs).
|
||||
- The release commit is a commit on `main`. Releases are tagged from `main` only
|
||||
(`TODO.md`, Workflow).
|
||||
- A clean checkout is a working tree (the checked-out files) at the release
|
||||
commit where `git status --porcelain` prints nothing. The build stamps the
|
||||
commit hash (the commit's id) into the extension and appends `-dirty` when the
|
||||
tree has local changes.
|
||||
- A tag is a name that git attaches to one commit. Release tags read `vX.Y.Z`,
|
||||
such as `v0.1.0`.
|
||||
- A digest is the sha256 hash of a file (a fixed-length fingerprint of its
|
||||
bytes), written as 64 hexadecimal characters.
|
||||
|
||||
## What you need
|
||||
|
||||
- A clean checkout of the release commit.
|
||||
- `make`.
|
||||
- Docker (a tool that runs programs in containers), for `script/cibuild` in
|
||||
step 1. `make package` needs no Docker.
|
||||
- Node and yarn, on the `PATH`. `make package` runs both directly.
|
||||
`script/bootstrap` can install both through nvm (a Node version manager), but
|
||||
it leaves them off the `PATH`.
|
||||
There is one version, declared in three files (`package.json`,
|
||||
`manifest/chrome.json`, `manifest/firefox.json`), and `make package` builds and
|
||||
packages but publishes nothing. `make build` and `make package` can be run by
|
||||
anyone; tagging, signing, packing a CRX and any upload need credentials only the
|
||||
owner ([@sneak](https://sneak.berlin)) holds and are marked **owner-only**
|
||||
below. Releases are tagged from `main` (see the Workflow section of `TODO.md`),
|
||||
so the "release commit" throughout is the `main` commit the milestone PR merged.
|
||||
|
||||
## Procedure
|
||||
|
||||
### 1. Confirm the release commit is green
|
||||
1. **Confirm `main` is green in CI.** The `check` workflow
|
||||
(`.gitea/workflows/check.yml`) runs `script/cibuild`, which runs
|
||||
`script/check` and then builds the image uncached, so a green `check` run is
|
||||
a green `make check`. Find the run for the exact release commit on the
|
||||
tracker's Actions view. _Check:_ that commit's `check` run succeeded; running
|
||||
`make check` on a clean checkout of the commit reproduces it and exits 0.
|
||||
|
||||
The `check` workflow (`.gitea/workflows/check.yml`) runs `script/cibuild` on
|
||||
every push. `script/cibuild` runs:
|
||||
2. **Confirm the version matches the intended tag.** `package.json`,
|
||||
`manifest/chrome.json` and `manifest/firefox.json` must all declare the same
|
||||
`X.Y.Z`. `make build` fails when they disagree, but nothing checks that they
|
||||
equal the tag you mean to create — that is this manual step. _Check:_ all
|
||||
three files read the same `X.Y.Z`, and it is the version you intend to tag
|
||||
`vX.Y.Z`.
|
||||
|
||||
- `script/bootstrap`, which installs the dependencies;
|
||||
- `script/check`, which is what `make check` runs;
|
||||
- the Docker image build (an image is Docker's packaged form of a program).
|
||||
3. **Build and package from a clean checkout of that commit.** From a fresh
|
||||
clone, or a working tree with no local modifications (`git status` clean),
|
||||
checked out at the release commit: run `make setup`, then `make package`.
|
||||
`make package` runs `make build` first, so the archives can only be made from
|
||||
a `dist/` verified against that build's own receipt as a release (not debug)
|
||||
build. It writes three files into `release/`:
|
||||
`autistmask-chrome-<version>.zip`, `autistmask-firefox-<version>.xpi`, and
|
||||
`SHA256SUMS`. _Check:_ those three files exist and `<version>` in the archive
|
||||
names is the version confirmed in step 2. The Firefox `.xpi` is **unsigned**
|
||||
(see step 6 and "Installing on Firefox" in `README.md`).
|
||||
|
||||
`script/check` runs:
|
||||
4. **Verify `SHA256SUMS`.** The archives are deterministic — sorted entries,
|
||||
fixed timestamps, fixed compression — so a second `make package` from another
|
||||
clean checkout of the same commit produces byte-identical files. Verify the
|
||||
recorded digests against the files with `sha256sum -c SHA256SUMS`, run from
|
||||
`release/`. To confirm reproducibility, run `make package` again on a
|
||||
separate clean checkout and compare the digests. _Check:_ `sha256sum -c`
|
||||
reports `OK` for every file, and an independent build's digests match.
|
||||
|
||||
- `script/test`: the tests, in Docker;
|
||||
- `script/lint`, which runs three checks in Docker:
|
||||
- ESLint, a code checker;
|
||||
- `prettier --check .`, the formatting check;
|
||||
- `script/check-censored`, which fails when the name that `RULES.md` bars
|
||||
appears outside its allowed places;
|
||||
- `script/fmt-check`: `prettier --check .` again, on the host.
|
||||
5. **Tag the release commit.** _(owner-only)_ Create an annotated tag `vX.Y.Z`
|
||||
on the release commit and push it: `git tag -a vX.Y.Z` (with a message), then
|
||||
`git push origin vX.Y.Z`. _Check:_ `git tag` lists `vX.Y.Z`, and
|
||||
`git rev-parse vX.Y.Z^{commit}` resolves to the release commit.
|
||||
|
||||
The `e2e` workflow (`.gitea/workflows/e2e.yml`) has two jobs. One runs
|
||||
`script/test-e2e`, the browser tests in Chrome. The other runs
|
||||
`script/test-e2e-firefox`, the browser tests in Firefox. A red `e2e` job does
|
||||
not fail the `check` run.
|
||||
6. **Distribute per browser.** _(owner-only; pending the owner's choice on
|
||||
https://git.eeqj.de/sneak/AutistMask/issues/386)_ How 1.0.0 is distributed on
|
||||
each browser is not yet decided; it is the open question on that issue, and
|
||||
the concrete steps cannot be written until the owner records a choice there.
|
||||
These steps need credentials only the owner holds. The options under
|
||||
consideration are:
|
||||
- **Firefox** — the packaged `.xpi` is unsigned, and release Firefox and ESR
|
||||
refuse an unsigned add-on:
|
||||
- (a) AMO self-distribution signing (unlisted): submit the `.xpi` to AMO
|
||||
with the owner's credentials; AMO returns a signed `.xpi` installable
|
||||
on every Firefox, with nothing listed publicly.
|
||||
- (b) AMO listed: as (a), plus a public AMO listing and review.
|
||||
- (c) Ship the unsigned `.xpi` and state that Firefox support means
|
||||
Developer Edition, Nightly, or an Unbranded build with
|
||||
`xpinstall.signatures.required` set to `false`.
|
||||
- **Chrome** — the repo packs no CRX and publishes nothing; the extension id
|
||||
is fixed by the `key` in `manifest/chrome.json`:
|
||||
- (a) Chrome Web Store (unlisted): upload the `.zip` with the owner's
|
||||
developer account; the store delivers installs and updates.
|
||||
- (b) Self-hosted CRX signed with the private key the owner holds
|
||||
(`chrome --pack-extension=dist/chrome --pack-extension-key=<path to the .pem>`),
|
||||
installable only via enterprise policy on Windows and macOS, so
|
||||
realistically Linux-only.
|
||||
- (c) "Load unpacked" from `dist/chrome/` only, as today.
|
||||
|
||||
Run `script/cibuild` on the clean checkout. `script/cibuild` runs the same steps
|
||||
as the `check` run, and must exit 0.
|
||||
|
||||
Check: on the Actions page, the `check` run for the release commit succeeded,
|
||||
and both `e2e` jobs for that commit succeeded. `script/cibuild` exited 0 on the
|
||||
clean checkout.
|
||||
|
||||
### 2. Confirm the version
|
||||
|
||||
Three files declare the version:
|
||||
|
||||
- `package.json`;
|
||||
- `manifest/chrome.json`;
|
||||
- `manifest/firefox.json`.
|
||||
|
||||
`script/lib/version.js` fails the build when the three disagree.
|
||||
`tests/version.test.js` fails when the version is not three numbers separated by
|
||||
dots. Nothing compares the version with a tag. That comparison is this step.
|
||||
|
||||
Check: all three files read the same `X.Y.Z`, and `vX.Y.Z` is the tag that the
|
||||
owner creates in step 5.
|
||||
|
||||
### 3. Build and package
|
||||
|
||||
On the clean checkout, run:
|
||||
|
||||
```bash
|
||||
make setup
|
||||
make package
|
||||
```
|
||||
|
||||
`make setup` installs two things:
|
||||
|
||||
- the dependencies, from the lockfile `yarn.lock`, which pins each one's
|
||||
version;
|
||||
- the git pre-commit hook, a script that git runs before each commit. Here the
|
||||
hook runs `script/check`.
|
||||
|
||||
`make package` runs `make build`, then `script/lib/package.js`.
|
||||
|
||||
`make build`:
|
||||
|
||||
- runs `build.js`. `build.js` writes `dist/chrome/`, `dist/firefox/` and a build
|
||||
receipt. The receipt lists every file that `build.js` wrote, with each file's
|
||||
digest. The receipt lives outside the repository and is deleted when the build
|
||||
ends;
|
||||
- runs `script/verify-build --expect release` against the receipt. The check
|
||||
fails when:
|
||||
- `dist/` differs from the receipt;
|
||||
- a bundle (one JavaScript file built from many source files) was compiled
|
||||
with the build-time constant `DEBUG` on;
|
||||
- any file carries the test recovery phrase, which a debug build gives every
|
||||
new wallet;
|
||||
- runs `script/check-censored --require-dist` against the built files;
|
||||
- removes `dist/` when any of those steps fails.
|
||||
|
||||
`script/lib/package.js`:
|
||||
|
||||
- empties `release/`;
|
||||
- refuses a symbolic link (a file that points at another file) under `dist/`;
|
||||
- checks that the browser's directory (`dist/chrome/` or `dist/firefox/`) holds
|
||||
every file named in `manifest.json` or in the popup's HTML page.
|
||||
`manifest.json` is the file that describes the extension to the browser. The
|
||||
popup is the window that the toolbar button opens;
|
||||
- checks that the `version` in each `manifest.json` is the version from step 2;
|
||||
- writes one archive per browser;
|
||||
- reads each archive back;
|
||||
- compares every member (a file inside the archive) with `dist/` byte for byte;
|
||||
- writes `SHA256SUMS`, with one line per archive:
|
||||
- the digest;
|
||||
- two spaces;
|
||||
- the file name.
|
||||
|
||||
`make package` writes three files:
|
||||
|
||||
```
|
||||
release/autistmask-chrome-<version>.zip
|
||||
release/autistmask-firefox-<version>.xpi
|
||||
release/SHA256SUMS
|
||||
```
|
||||
|
||||
The `.xpi` is Firefox's add-on package file (an add-on is Firefox's word for an
|
||||
extension). The `.xpi` is not signed.
|
||||
|
||||
`make package` prints a line that starts `Not shipped` and names `styles.css`.
|
||||
This is expected: each archive holds its own copy of the stylesheet.
|
||||
|
||||
Check: `release/` holds those three files, and `<version>` in their names is the
|
||||
version from step 2.
|
||||
|
||||
### 4. Verify the digests
|
||||
|
||||
From `release/`, run `sha256sum -c SHA256SUMS`.
|
||||
|
||||
The archives are deterministic for a given `dist/`: the same `dist/` always
|
||||
gives the same bytes. `script/lib/zip.js`:
|
||||
|
||||
- sorts the members;
|
||||
- sets every member's timestamp (its recorded date) to 1980-01-01;
|
||||
- compresses each member the same way every time.
|
||||
|
||||
`dist/` itself carries the build date. `build.js` compiles the build date, a UTC
|
||||
(universal time) day, into the extension. So two builds of the same commit on
|
||||
the same UTC day give byte-identical archives. Builds on different days differ.
|
||||
|
||||
Check: `sha256sum -c` prints `OK` for both archives. On the same UTC day, a
|
||||
second `make package` from another clean checkout of the same commit gives the
|
||||
same `SHA256SUMS`.
|
||||
|
||||
### 5. Tag the release commit
|
||||
|
||||
Owner only. Only the owner decides whether and when a release is tagged. Only
|
||||
the owner creates, moves or deletes a tag. On the release commit, the owner
|
||||
runs:
|
||||
|
||||
```bash
|
||||
git tag -a vX.Y.Z -m "AutistMask X.Y.Z"
|
||||
git push origin vX.Y.Z
|
||||
```
|
||||
|
||||
`-a` makes an annotated tag: a tag that carries a message and records who made
|
||||
the tag and when. `v0.1.0` is one.
|
||||
|
||||
Once the tag exists, `git describe --tags` on the release commit prints
|
||||
`vX.Y.Z`. `script/cibuild` and `script/docker` pass that value to the Docker
|
||||
image build as `VERSION`.
|
||||
|
||||
Check: `git rev-parse vX.Y.Z^{commit}` prints the release commit's hash, and the
|
||||
tag is listed at https://git.eeqj.de/sneak/AutistMask/tags.
|
||||
|
||||
### 6. Publish the archives
|
||||
|
||||
Owner only. The owner decides where the archives are published. No script in
|
||||
this repository uploads or publishes them.
|
||||
|
||||
Whoever receives an archive installs it as follows.
|
||||
|
||||
Chrome loads the extension from a directory:
|
||||
|
||||
- unzip the archive into a new, empty directory, for example
|
||||
`unzip autistmask-chrome-0.1.0.zip -d autistmask-chrome`;
|
||||
- open `chrome://extensions/` and turn on "Developer mode";
|
||||
- click "Load unpacked" and pick that directory.
|
||||
|
||||
Chrome then reports the extension id `gipbhkogfopeahplcjhipkgpcimdpkip`. The id
|
||||
is the fixed string that identifies the extension to Chrome; the `key` in
|
||||
`manifest/chrome.json` sets the id.
|
||||
|
||||
Release builds of Firefox refuse to install an unsigned add-on. Desktop Firefox
|
||||
115 or newer, in any edition, loads the `.xpi` as a temporary add-on from the
|
||||
`about:debugging` page. Firefox unloads a temporary add-on when Firefox exits.
|
||||
The section "Installing on Firefox" in `README.md` has the details.
|
||||
|
||||
Check: each archive installs on a fresh browser profile (a new, empty set of
|
||||
browser data) by the route above.
|
||||
Once the owner decides, the chosen steps — including which credentials they
|
||||
need and who holds them — are written into this section and `README.md`'s
|
||||
installation sections are updated to match, which is part of the definition
|
||||
of done of https://git.eeqj.de/sneak/AutistMask/issues/386. _Check:_ for a
|
||||
store or AMO route, the artifact installs from the store or AMO on a clean
|
||||
browser profile; for the CRX or unpacked route, the documented load succeeds
|
||||
and Chrome reports the extension id `gipbhkogfopeahplcjhipkgpcimdpkip`.
|
||||
|
||||
+2
-1
@@ -153,7 +153,8 @@ module.exports = [
|
||||
},
|
||||
},
|
||||
|
||||
// The files in script/lib/ run on plain node too, and are never bundled.
|
||||
// The helpers the script/ entrypoints call: plain node programs too, run
|
||||
// from a shell script rather than from yarn, and never bundled.
|
||||
{
|
||||
files: ["script/lib/**/*.js"],
|
||||
languageOptions: {
|
||||
|
||||
+2
-2
@@ -6,8 +6,8 @@
|
||||
"license": "GPL-3.0",
|
||||
"private": true,
|
||||
"scripts": {
|
||||
"test": "node script/lib/jest.js --maxWorkers=3",
|
||||
"test:verbose": "node script/lib/jest.js --maxWorkers=3 --verbose",
|
||||
"test": "jest --forceExit --maxWorkers=3",
|
||||
"test:verbose": "jest --forceExit --maxWorkers=3 --verbose",
|
||||
"build": "node build.js",
|
||||
"lint": "eslint . && prettier --check .",
|
||||
"fmt": "prettier --write .",
|
||||
|
||||
@@ -118,7 +118,6 @@ ensure_yarn() {
|
||||
fi
|
||||
}
|
||||
|
||||
# yarn warns about the workspaces field in eslint and babel-plugin-istanbul; no newer release drops it.
|
||||
install_js_deps() {
|
||||
if missing yarn && [ -s "$HOME/.nvm/nvm.sh" ]; then
|
||||
nvm_sh "nvm use $NODE_VERSION >/dev/null && cd \"$ROOT\" && \
|
||||
|
||||
@@ -1,40 +0,0 @@
|
||||
// Runs jest with the arguments it is given, and fails the run when jest had to
|
||||
// force-stop the worker process that ran a test file. Jest itself only prints a
|
||||
// warning when that happens, and its run still passes. The warning means a test
|
||||
// left a timer or another open handle running. The test scripts in package.json
|
||||
// run jest through this file.
|
||||
//
|
||||
// Jest runs inside this process and writes to the terminal directly, so its
|
||||
// output looks the same as a plain jest run. This file only checks each write
|
||||
// to stderr for the warning below.
|
||||
|
||||
"use strict";
|
||||
|
||||
// The start of the warning that jest prints on stderr after it force-stops a
|
||||
// worker process.
|
||||
const WORKER_WARNING = "A worker process has failed to exit gracefully";
|
||||
|
||||
let forceStopped = false;
|
||||
|
||||
const writeStderr = process.stderr.write.bind(process.stderr);
|
||||
process.stderr.write = (chunk, ...rest) => {
|
||||
if (String(chunk).includes(WORKER_WARNING)) {
|
||||
forceStopped = true;
|
||||
}
|
||||
return writeStderr(chunk, ...rest);
|
||||
};
|
||||
|
||||
// Runs after jest has finished, as the process exits.
|
||||
process.on("exit", () => {
|
||||
if (forceStopped) {
|
||||
console.error(
|
||||
"script/lib/jest.js: failing the run, because jest force-stopped " +
|
||||
"a worker process. A test left a timer or another open " +
|
||||
"handle running.",
|
||||
);
|
||||
process.exitCode = 1;
|
||||
}
|
||||
});
|
||||
|
||||
// Jest's own command-line program. It reads its arguments from process.argv.
|
||||
require("jest/bin/jest");
|
||||
@@ -1994,11 +1994,10 @@
|
||||
>Erasing the saved data deletes every wallet stored in
|
||||
this browser.</strong
|
||||
>
|
||||
Nothing on the blockchain changes and no money is moved. If
|
||||
you kept a copy of a wallet's recovery phrase, private key
|
||||
or extended private key, you can add that wallet again.
|
||||
Without that copy or the exported copy above, everything the
|
||||
wallet holds is gone forever.
|
||||
Nothing on the blockchain changes and no money is moved, but
|
||||
without the exported copy above, or the recovery phrase for
|
||||
each wallet written down, everything they hold is gone
|
||||
forever.
|
||||
</p>
|
||||
<p class="text-xs mb-1">
|
||||
To confirm, type
|
||||
|
||||
+12
-44
@@ -6,7 +6,6 @@ const {
|
||||
saveState,
|
||||
onSaveFailure,
|
||||
takeStoredNetwork,
|
||||
clearBalanceNotFetched,
|
||||
loadState,
|
||||
} = require("../shared/state");
|
||||
const { StateUnusableError } = require("../shared/stateSchema");
|
||||
@@ -66,14 +65,7 @@ function renderWalletList() {
|
||||
const pageClosed = new AbortController();
|
||||
window.addEventListener("pagehide", () => pageClosed.abort());
|
||||
|
||||
// While a refresh runs, a request through ctx is not dropped. The request sets
|
||||
// refreshAgain, and one more refresh runs once the running one ends. Several
|
||||
// requests in that time lead to one more refresh, not several. An import asks
|
||||
// for a refresh after its address scan. A refresh already running does not
|
||||
// have the addresses the scan found
|
||||
// (https://git.eeqj.de/sneak/AutistMask/issues/581).
|
||||
let refreshInFlight = false;
|
||||
let refreshAgain = false;
|
||||
|
||||
// The ten-second refresh startRefresh() starts, stopped when the popup moves to
|
||||
// the recovery screen: there is no profile left to refresh.
|
||||
@@ -96,29 +88,15 @@ let refreshTimer = null;
|
||||
// removed meanwhile is left as it is. Blockscout may have answered before the
|
||||
// user turned "Use Blockscout" off. So the save drops every token the user has
|
||||
// not tracked if the stored setting is off by then.
|
||||
//
|
||||
// The save also deletes `balanceNotFetched` from each tracked token whose
|
||||
// balance this refresh read at every address. trackToken() in
|
||||
// src/popup/views/helpers.js sets that field. The save takes the field off the
|
||||
// matching tokens of the stored record (clearBalanceNotFetched() in
|
||||
// src/shared/state.js). The rest of the stored tracked token list stays as it
|
||||
// is.
|
||||
//
|
||||
// Once the save is done, the wallet list is drawn again. So are the balances
|
||||
// on AddressDetail or AddressToken when that screen is up. No other screen is
|
||||
// drawn again, DeleteAddress and its balance lines included.
|
||||
async function doRefreshAndRender() {
|
||||
if (refreshInFlight) {
|
||||
refreshAgain = true;
|
||||
return;
|
||||
}
|
||||
if (refreshInFlight) return;
|
||||
refreshInFlight = true;
|
||||
try {
|
||||
await followStoredSettings();
|
||||
const networkId = state.networkId;
|
||||
const wallets = structuredClone(state.wallets);
|
||||
const [, readTokens] = await Promise.all([
|
||||
refreshPrices(pageClosed.signal),
|
||||
await Promise.all([
|
||||
refreshPrices(),
|
||||
refreshBalances(
|
||||
wallets,
|
||||
state.rpcUrl,
|
||||
@@ -149,43 +127,33 @@ async function doRefreshAndRender() {
|
||||
if (!stored.useBlockscout) {
|
||||
dropUntrackedTokens(state.wallets, stored.trackedTokens);
|
||||
}
|
||||
clearBalanceNotFetched(stored, readTokens);
|
||||
state.lastBalanceRefresh = Date.now();
|
||||
return true;
|
||||
});
|
||||
renderWalletList();
|
||||
if (state.currentView === "address") addressDetail.renderBalances();
|
||||
if (state.currentView === "address-token") addressToken.renderBalance();
|
||||
} catch (e) {
|
||||
// No caller waits for this function, so it must never reject. An
|
||||
// unhandled rejection reports nothing. The save inside it reports its
|
||||
// own failure through onSaveFailure() (see src/shared/state.js); what
|
||||
// is left here is a failed network round trip, which the next tick
|
||||
// retries.
|
||||
// Every call site fires this and walks away — the boot below, the ten
|
||||
// second interval, and eight views through ctx — so it must never
|
||||
// reject: an unhandled rejection is not a report of anything. The save
|
||||
// inside it reports its own failure through onSaveFailure() (see
|
||||
// src/shared/state.js); what is left here is a failed network round
|
||||
// trip, which the next tick retries.
|
||||
log.errorf("popup: background refresh failed:", e);
|
||||
} finally {
|
||||
refreshInFlight = false;
|
||||
}
|
||||
if (refreshAgain) {
|
||||
refreshAgain = false;
|
||||
doRefreshAndRender();
|
||||
}
|
||||
}
|
||||
|
||||
// Refreshes now and every ten seconds from then on. Called once a wallet
|
||||
// exists: by init() when the popup opens with one, and by AddWallet when it
|
||||
// adds one, which in a popup that opened on Welcome is the first
|
||||
// (https://git.eeqj.de/sneak/AutistMask/issues/530). With the ten-second
|
||||
// refresh already started, it starts no second one. On the recovery screen it
|
||||
// does nothing.
|
||||
// (https://git.eeqj.de/sneak/AutistMask/issues/530). With the refresh already
|
||||
// running it starts no second one, and on the recovery screen it does nothing.
|
||||
function startRefresh() {
|
||||
if (!$("view-state-recovery").classList.contains("hidden")) return;
|
||||
doRefreshAndRender();
|
||||
if (refreshTimer === null) {
|
||||
// A tick that finds a refresh running is dropped.
|
||||
refreshTimer = setInterval(() => {
|
||||
if (!refreshInFlight) return doRefreshAndRender();
|
||||
}, 10000);
|
||||
refreshTimer = setInterval(doRefreshAndRender, 10000);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,24 +1,11 @@
|
||||
const {
|
||||
$,
|
||||
showView,
|
||||
showFlash,
|
||||
escapeHtml,
|
||||
goBack,
|
||||
trackToken,
|
||||
} = require("./helpers");
|
||||
const { $, showView, showFlash, escapeHtml, goBack } = require("./helpers");
|
||||
const { getTopTokens } = require("../../shared/tokenList");
|
||||
const { state, saveState, currentNetwork } = require("../../shared/state");
|
||||
const { lookupTokenInfo } = require("../../shared/balances");
|
||||
const { isScamAddress } = require("../../shared/scamlist");
|
||||
const { isSpoofedSymbol } = require("../../shared/symbolSpoof");
|
||||
const { log } = require("../../shared/log");
|
||||
|
||||
// Counts the times AddToken has opened. A contract lookup started before
|
||||
// AddToken was last opened changes neither the screen nor the status line.
|
||||
let addTokenScreenOpenings = 0;
|
||||
|
||||
function show() {
|
||||
addTokenScreenOpenings++;
|
||||
$("add-token-address").value = "";
|
||||
$("add-token-info").textContent = "";
|
||||
$("add-token-info").style.visibility = "hidden";
|
||||
@@ -68,7 +55,6 @@ function init(ctx) {
|
||||
// The network the lookup asks, which Settings may switch away from
|
||||
// before it answers, as for a transaction in confirmTx.js.
|
||||
const chainId = currentNetwork().chainId;
|
||||
const opening = addTokenScreenOpenings;
|
||||
try {
|
||||
const info = await lookupTokenInfo(
|
||||
contractAddr,
|
||||
@@ -85,17 +71,8 @@ function init(ctx) {
|
||||
);
|
||||
return;
|
||||
}
|
||||
// The balance list never shows a token that the spoof rule
|
||||
// refuses, so such a token is not tracked.
|
||||
if (isSpoofedSymbol(info.symbol, contractAddr, chainId)) {
|
||||
showFlash("Not added: this token fakes a known symbol.");
|
||||
if (addTokenScreenOpenings !== opening) return;
|
||||
infoEl.textContent = "";
|
||||
infoEl.style.visibility = "hidden";
|
||||
return;
|
||||
}
|
||||
log.infof("Adding token", info.symbol, contractAddr);
|
||||
trackToken({
|
||||
state.trackedTokens.push({
|
||||
address: contractAddr,
|
||||
symbol: info.symbol,
|
||||
decimals: info.decimals,
|
||||
@@ -103,17 +80,6 @@ function init(ctx) {
|
||||
});
|
||||
await saveState();
|
||||
ctx.doRefreshAndRender();
|
||||
// If the lookup answers after AddToken was opened again, the
|
||||
// token is still added, but the screen and the status line stay
|
||||
// as they are.
|
||||
if (addTokenScreenOpenings !== opening) return;
|
||||
// The lookup is over, so a later Back onto AddToken shows no
|
||||
// status.
|
||||
infoEl.textContent = "";
|
||||
infoEl.style.visibility = "hidden";
|
||||
// If the lookup answers while another screen shows, the token is
|
||||
// still added but the screen does not change.
|
||||
if (state.currentView !== "add-token") return;
|
||||
// Pop the stack (back to address detail) and re-render it
|
||||
// so the newly added token is visible immediately.
|
||||
if (state.viewStack.length > 0) {
|
||||
@@ -134,7 +100,6 @@ function init(ctx) {
|
||||
? detail
|
||||
: "Could not add the token.",
|
||||
);
|
||||
if (addTokenScreenOpenings !== opening) return;
|
||||
infoEl.textContent = "";
|
||||
infoEl.style.visibility = "hidden";
|
||||
}
|
||||
|
||||
@@ -22,7 +22,6 @@ const {
|
||||
filterTransactions,
|
||||
} = require("../../shared/transactions");
|
||||
const { resolveEnsNames } = require("../../shared/ens");
|
||||
const { storedNetworkIs } = require("../../shared/storedSettings");
|
||||
const {
|
||||
updateSendBalance,
|
||||
renderSendTokenSelect,
|
||||
@@ -67,27 +66,11 @@ function show() {
|
||||
});
|
||||
$("address-line").dataset.full = addr.address;
|
||||
attachCopyHandlers($("address-line"));
|
||||
const usdTotal = formatAddressTotal(getAddressValue(addr));
|
||||
$("address-usd-total").innerHTML = escapeHtml(usdTotal) || " ";
|
||||
const ensEl = $("address-ens");
|
||||
// ENS is now shown inside renderAddressHtml, hide the separate element
|
||||
ensEl.classList.add("hidden");
|
||||
renderBalances();
|
||||
// Only Blockscout reports the tokens the user has not tracked.
|
||||
$("address-tokens-note").classList.toggle("hidden", !!state.useBlockscout);
|
||||
renderSendTokenSelect(addr);
|
||||
$("tx-list").innerHTML =
|
||||
'<div class="text-muted text-xs py-1">Loading...</div>';
|
||||
showView("address");
|
||||
loadTransactions(addr.address);
|
||||
}
|
||||
|
||||
// The USD total and the balance list. Drawn again by each balance refresh
|
||||
// that returns while this screen is up (doRefreshAndRender() in
|
||||
// src/popup/index.js), which leaves the rest of the screen as it is.
|
||||
function renderBalances() {
|
||||
const addr =
|
||||
state.wallets[state.selectedWallet].addresses[state.selectedAddress];
|
||||
const usdTotal = formatAddressTotal(getAddressValue(addr));
|
||||
$("address-usd-total").innerHTML = escapeHtml(usdTotal) || " ";
|
||||
$("address-balances").innerHTML = balanceLinesForAddress(
|
||||
addr,
|
||||
state.trackedTokens,
|
||||
@@ -101,6 +84,13 @@ function renderBalances() {
|
||||
ctx.showAddressToken();
|
||||
});
|
||||
});
|
||||
// Only Blockscout reports the tokens the user has not tracked.
|
||||
$("address-tokens-note").classList.toggle("hidden", !!state.useBlockscout);
|
||||
renderSendTokenSelect(addr);
|
||||
$("tx-list").innerHTML =
|
||||
'<div class="text-muted text-xs py-1">Loading...</div>';
|
||||
showView("address");
|
||||
loadTransactions(addr.address);
|
||||
}
|
||||
|
||||
let loadedTxs = [];
|
||||
@@ -108,7 +98,6 @@ let loadedTxs = [];
|
||||
let ensNameMap = new Map();
|
||||
|
||||
async function loadTransactions(address) {
|
||||
const networkId = state.networkId;
|
||||
try {
|
||||
const rawTxs = await fetchRecentTransactions(
|
||||
address,
|
||||
@@ -125,74 +114,43 @@ async function loadTransactions(address) {
|
||||
});
|
||||
const txs = result.transactions;
|
||||
|
||||
// Persist any newly discovered fraud contracts
|
||||
if (result.newFraudContracts.length > 0) {
|
||||
for (const addr of result.newFraudContracts) {
|
||||
if (!state.fraudContracts.includes(addr)) {
|
||||
state.fraudContracts.push(addr);
|
||||
}
|
||||
}
|
||||
await saveState();
|
||||
}
|
||||
|
||||
loadedTxs = txs;
|
||||
|
||||
// Collect ALL unique addresses (from + to) for ENS resolution so
|
||||
// that reverse lookups work for every displayed address, not just
|
||||
// the ones that were originally entered as ENS names.
|
||||
const counterparties = [
|
||||
...new Set(txs.flatMap((tx) => [tx.from, tx.to].filter(Boolean))),
|
||||
];
|
||||
let names = new Map();
|
||||
if (counterparties.length > 0) {
|
||||
try {
|
||||
names = await resolveEnsNames(
|
||||
ensNameMap = await resolveEnsNames(
|
||||
counterparties,
|
||||
state.rpcUrl,
|
||||
state.networkId,
|
||||
ctx.pageClosed,
|
||||
);
|
||||
} catch {
|
||||
// The rows then show no ENS names.
|
||||
ensNameMap = new Map();
|
||||
}
|
||||
}
|
||||
|
||||
// If the network changed during the lookups above, or the screen now
|
||||
// shows another address, nothing is saved or drawn. See
|
||||
// src/shared/storedSettings.js.
|
||||
if (
|
||||
state.networkId !== networkId ||
|
||||
!(await storedNetworkIs(networkId)) ||
|
||||
$("address-line").dataset.full !== address
|
||||
) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Persist any newly discovered fraud contracts, inside the save and
|
||||
// holding the lock. Nothing is added unless this page and the stored
|
||||
// record both still name the request's network.
|
||||
if (result.newFraudContracts.length > 0) {
|
||||
let saved = false;
|
||||
await saveState((stored) => {
|
||||
if (state.networkId !== networkId) return false;
|
||||
if (stored.networkId !== networkId) return false;
|
||||
for (const addr of result.newFraudContracts) {
|
||||
if (!state.fraudContracts.includes(addr)) {
|
||||
state.fraudContracts.push(addr);
|
||||
}
|
||||
}
|
||||
saved = true;
|
||||
});
|
||||
// If the network changed while the save waited for the lock,
|
||||
// nothing is drawn.
|
||||
if (!saved) return;
|
||||
}
|
||||
|
||||
loadedTxs = txs;
|
||||
ensNameMap = names;
|
||||
renderTransactions(txs);
|
||||
} catch (e) {
|
||||
// Cancelled by the popup closing, not failed: see pageClosed in
|
||||
// src/popup/index.js.
|
||||
if (ctx.pageClosed.aborted) return;
|
||||
log.errorf("loadTransactions failed:", e.message);
|
||||
// If the network changed, or the screen now shows another address,
|
||||
// the failure is not shown.
|
||||
if (
|
||||
state.networkId !== networkId ||
|
||||
!(await storedNetworkIs(networkId)) ||
|
||||
$("address-line").dataset.full !== address
|
||||
) {
|
||||
return;
|
||||
}
|
||||
$("tx-list").innerHTML =
|
||||
'<div class="text-muted text-xs py-1">Failed to load transactions.</div>';
|
||||
}
|
||||
@@ -329,4 +287,4 @@ function init(_ctx) {
|
||||
exportPrivkey.init();
|
||||
}
|
||||
|
||||
module.exports = { init, show, renderBalances };
|
||||
module.exports = { init, show };
|
||||
|
||||
+44
-101
@@ -22,14 +22,13 @@ const {
|
||||
timeAgo,
|
||||
} = require("./helpers");
|
||||
const { state, saveState, currentNetwork } = require("../../shared/state");
|
||||
const { bundledToken, resolveSymbol } = require("../../shared/tokenList");
|
||||
const { TOKEN_BY_ADDRESS, resolveSymbol } = require("../../shared/tokenList");
|
||||
const { formatUsd, getPrice } = require("../../shared/prices");
|
||||
const {
|
||||
fetchRecentTransactions,
|
||||
filterTransactions,
|
||||
} = require("../../shared/transactions");
|
||||
const { resolveEnsNames } = require("../../shared/ens");
|
||||
const { storedNetworkIs } = require("../../shared/storedSettings");
|
||||
const {
|
||||
updateSendBalance,
|
||||
renderSendTokenSelect,
|
||||
@@ -50,24 +49,37 @@ function show() {
|
||||
const addr = wallet.addresses[state.selectedAddress];
|
||||
const ai = state.selectedAddress;
|
||||
const tokenId = state.selectedToken;
|
||||
const chainId = currentNetwork().chainId;
|
||||
const knownToken = bundledToken(tokenId, chainId);
|
||||
currentSymbol =
|
||||
tokenId === "ETH"
|
||||
? nativeCurrency()
|
||||
: resolveSymbol(
|
||||
|
||||
// Determine token symbol and balance
|
||||
let symbol, amount, price;
|
||||
const knownToken = TOKEN_BY_ADDRESS.get(tokenId.toLowerCase());
|
||||
if (tokenId === "ETH") {
|
||||
symbol = nativeCurrency();
|
||||
amount = parseFloat(addr.balance || "0");
|
||||
price = getPrice("ETH");
|
||||
} else {
|
||||
const tb = (addr.tokenBalances || []).find(
|
||||
(t) => t.address.toLowerCase() === tokenId.toLowerCase(),
|
||||
);
|
||||
symbol = resolveSymbol(
|
||||
tokenId,
|
||||
addr.tokenBalances,
|
||||
state.trackedTokens,
|
||||
chainId,
|
||||
);
|
||||
// null when the scale is unknown: no quantity to show, and none to
|
||||
// price. balanceLine() states that rather than printing 0.0000.
|
||||
amount = tb ? unknownableAmount(tb.balance) : 0;
|
||||
price = getPrice(symbol);
|
||||
}
|
||||
|
||||
currentSymbol = symbol;
|
||||
|
||||
$("address-token-title").textContent =
|
||||
wallet.name +
|
||||
" \u2014 Address " +
|
||||
(ai + 1) +
|
||||
" \u2014 " +
|
||||
displaySymbol(currentSymbol);
|
||||
displaySymbol(symbol);
|
||||
|
||||
// Blockie
|
||||
const blockieEl = $("address-token-jazzicon");
|
||||
@@ -89,7 +101,13 @@ function show() {
|
||||
$("address-token-line").dataset.full = addr.address;
|
||||
attachCopyHandlers($("address-token-line"));
|
||||
|
||||
renderBalance();
|
||||
// USD total for this token only
|
||||
const usdVal = price && amount !== null ? amount * price : null;
|
||||
const usdStr = formatUsd(usdVal);
|
||||
$("address-token-usd-total").innerHTML = escapeHtml(usdStr) || " ";
|
||||
|
||||
// Single token balance line (no tokenId — not clickable here)
|
||||
$("address-token-balance").innerHTML = balanceLine(symbol, amount, price);
|
||||
|
||||
// Token contract details (ERC-20 only)
|
||||
const contractInfo = $("address-token-contract-info");
|
||||
@@ -151,49 +169,7 @@ function show() {
|
||||
loadTransactions(addr.address, tokenId);
|
||||
}
|
||||
|
||||
// The USD total and the balance line of the selected token. Drawn again by
|
||||
// each balance refresh that returns while this screen is up
|
||||
// (doRefreshAndRender() in src/popup/index.js), which leaves the rest of the
|
||||
// screen as it is.
|
||||
function renderBalance() {
|
||||
const addr =
|
||||
state.wallets[state.selectedWallet].addresses[state.selectedAddress];
|
||||
const tokenId = state.selectedToken;
|
||||
let amount, price;
|
||||
if (tokenId === "ETH") {
|
||||
amount = parseFloat(addr.balance || "0");
|
||||
price = getPrice("ETH");
|
||||
} else {
|
||||
const id = tokenId.toLowerCase();
|
||||
const tb = (addr.tokenBalances || []).find(
|
||||
(t) => t.address.toLowerCase() === id,
|
||||
);
|
||||
const tracked = state.trackedTokens.find(
|
||||
(t) => t.address.toLowerCase() === id,
|
||||
);
|
||||
// null when the scale is unknown, or when no refresh has read the
|
||||
// balance of a token just added: no quantity to show, and none to
|
||||
// price. balanceLine() states that rather than printing 0.0000.
|
||||
if (tb) amount = unknownableAmount(tb.balance);
|
||||
else amount = tracked && tracked.balanceNotFetched ? null : 0;
|
||||
price = getPrice(tokenId);
|
||||
}
|
||||
|
||||
// USD total for this token only
|
||||
const usdVal = price && amount !== null ? amount * price : null;
|
||||
const usdStr = formatUsd(usdVal);
|
||||
$("address-token-usd-total").innerHTML = escapeHtml(usdStr) || " ";
|
||||
|
||||
// Single token balance line (no tokenId — not clickable here)
|
||||
$("address-token-balance").innerHTML = balanceLine(
|
||||
currentSymbol,
|
||||
amount,
|
||||
price,
|
||||
);
|
||||
}
|
||||
|
||||
async function loadTransactions(address, tokenId) {
|
||||
const networkId = state.networkId;
|
||||
try {
|
||||
const rawTxs = await fetchRecentTransactions(
|
||||
address,
|
||||
@@ -210,6 +186,16 @@ async function loadTransactions(address, tokenId) {
|
||||
});
|
||||
let txs = result.transactions;
|
||||
|
||||
// Persist any newly discovered fraud contracts
|
||||
if (result.newFraudContracts.length > 0) {
|
||||
for (const addr of result.newFraudContracts) {
|
||||
if (!state.fraudContracts.includes(addr)) {
|
||||
state.fraudContracts.push(addr);
|
||||
}
|
||||
}
|
||||
await saveState();
|
||||
}
|
||||
|
||||
// Filter to this token only
|
||||
if (tokenId === "ETH") {
|
||||
txs = txs.filter((tx) => tx.contractAddress === null);
|
||||
@@ -221,75 +207,32 @@ async function loadTransactions(address, tokenId) {
|
||||
);
|
||||
}
|
||||
|
||||
loadedTxs = txs;
|
||||
|
||||
// Collect ALL unique addresses for ENS resolution so reverse
|
||||
// lookups work for every displayed address.
|
||||
const counterparties = [
|
||||
...new Set(txs.flatMap((tx) => [tx.from, tx.to].filter(Boolean))),
|
||||
];
|
||||
let names = new Map();
|
||||
if (counterparties.length > 0) {
|
||||
try {
|
||||
names = await resolveEnsNames(
|
||||
ensNameMap = await resolveEnsNames(
|
||||
counterparties,
|
||||
state.rpcUrl,
|
||||
state.networkId,
|
||||
ctx.pageClosed,
|
||||
);
|
||||
} catch {
|
||||
// The rows then show no ENS names.
|
||||
ensNameMap = new Map();
|
||||
}
|
||||
}
|
||||
|
||||
// If the network changed during the lookups above, or the screen now
|
||||
// shows another address or token, nothing is saved or drawn. See
|
||||
// src/shared/storedSettings.js.
|
||||
if (
|
||||
state.networkId !== networkId ||
|
||||
!(await storedNetworkIs(networkId)) ||
|
||||
$("address-token-line").dataset.full !== address ||
|
||||
state.selectedToken !== tokenId
|
||||
) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Persist any newly discovered fraud contracts, inside the save and
|
||||
// holding the lock. Nothing is added unless this page and the stored
|
||||
// record both still name the request's network.
|
||||
if (result.newFraudContracts.length > 0) {
|
||||
let saved = false;
|
||||
await saveState((stored) => {
|
||||
if (state.networkId !== networkId) return false;
|
||||
if (stored.networkId !== networkId) return false;
|
||||
for (const addr of result.newFraudContracts) {
|
||||
if (!state.fraudContracts.includes(addr)) {
|
||||
state.fraudContracts.push(addr);
|
||||
}
|
||||
}
|
||||
saved = true;
|
||||
});
|
||||
// If the network changed while the save waited for the lock,
|
||||
// nothing is drawn.
|
||||
if (!saved) return;
|
||||
}
|
||||
|
||||
loadedTxs = txs;
|
||||
ensNameMap = names;
|
||||
renderTransactions(txs);
|
||||
} catch (e) {
|
||||
// Cancelled by the popup closing, not failed: see pageClosed in
|
||||
// src/popup/index.js.
|
||||
if (ctx.pageClosed.aborted) return;
|
||||
log.errorf("loadTransactions failed:", e.message);
|
||||
// If the network changed, or the screen now shows another address or
|
||||
// token, the failure is not shown.
|
||||
if (
|
||||
state.networkId !== networkId ||
|
||||
!(await storedNetworkIs(networkId)) ||
|
||||
$("address-token-line").dataset.full !== address ||
|
||||
state.selectedToken !== tokenId
|
||||
) {
|
||||
return;
|
||||
}
|
||||
$("address-token-tx-list").innerHTML =
|
||||
'<div class="text-muted text-xs py-1">Failed to load transactions.</div>';
|
||||
}
|
||||
@@ -405,4 +348,4 @@ function init(_ctx) {
|
||||
});
|
||||
}
|
||||
|
||||
module.exports = { init, show, renderBalance };
|
||||
module.exports = { init, show };
|
||||
|
||||
@@ -129,7 +129,7 @@ function renderAmount(txInfo) {
|
||||
const rawSymbol = isErc20
|
||||
? txInfo.tokenSymbol || "?"
|
||||
: nativeCurrencyByChainId(txInfo.chainId);
|
||||
const price = getPrice(txInfo.token, txInfo.chainId);
|
||||
const price = getPrice(isErc20 ? rawSymbol : "ETH", txInfo.chainId);
|
||||
const amountUsd = price ? parseFloat(txInfo.amount) * price : null;
|
||||
$("confirm-amount").textContent = valueWithUsd(
|
||||
shownAmount(txInfo) + " " + displaySymbol(rawSymbol),
|
||||
@@ -157,7 +157,7 @@ function renderBalance(txInfo) {
|
||||
$("confirm-balance").textContent = "unknown (" + symbol + ")";
|
||||
return;
|
||||
}
|
||||
const price = getPrice(txInfo.token, txInfo.chainId);
|
||||
const price = getPrice(isErc20 ? rawSymbol : "ETH", txInfo.chainId);
|
||||
const balUsd = price ? parseFloat(bal) * price : null;
|
||||
$("confirm-balance").textContent = valueWithUsd(
|
||||
truncateAmountNeverZero(bal) + " " + symbol,
|
||||
|
||||
@@ -33,7 +33,6 @@ const { networkByChainId } = require("../../shared/networks");
|
||||
const { formatUsd, getPrice } = require("../../shared/prices");
|
||||
const { state, saveState, currentNetwork } = require("../../shared/state");
|
||||
const { displaySymbol } = require("../../shared/symbolDisplay");
|
||||
const { isSpoofedSymbol } = require("../../shared/symbolSpoof");
|
||||
const { walletHasRecoveryPhrase } = require("../../shared/wallet");
|
||||
const { markViewRendered } = require("../viewRouter");
|
||||
|
||||
@@ -314,17 +313,14 @@ function nativeCurrency() {
|
||||
// The wallets' balances hold what Blockscout reported for each token. So the
|
||||
// wallets are returned only while "Use Blockscout" is on.
|
||||
function tokenSourcesByChainId(chainId) {
|
||||
const chainIdOrActive = chainId || currentNetwork().chainId;
|
||||
const net = networkByChainId(chainIdOrActive);
|
||||
const net = chainId ? networkByChainId(chainId) : currentNetwork();
|
||||
if (net && net.id === state.networkId) {
|
||||
return {
|
||||
chainId: chainIdOrActive,
|
||||
trackedTokens: state.trackedTokens,
|
||||
wallets: state.useBlockscout ? state.wallets : [],
|
||||
};
|
||||
}
|
||||
return {
|
||||
chainId: chainIdOrActive,
|
||||
trackedTokens: (net && state.networkTrackedTokens[net.id]) || [],
|
||||
wallets: [],
|
||||
};
|
||||
@@ -355,7 +351,7 @@ function blockscoutOffTokenNoteHtml(token, chainId) {
|
||||
|
||||
// The symbol shown for a token line, from these sources in order:
|
||||
//
|
||||
// - the bundled list, for a token on Ethereum Mainnet
|
||||
// - the bundled list
|
||||
// - the tokens the user tracks
|
||||
// - the explorer's report, while "Use Blockscout" is on
|
||||
//
|
||||
@@ -421,15 +417,6 @@ function balanceLine(symbol, amount, price, tokenId) {
|
||||
);
|
||||
}
|
||||
|
||||
// Tracks `token` on the active network, as every add path on AddToken and
|
||||
// SettingsAddToken does. The tracked record carries `balanceNotFetched: true`
|
||||
// until a balance refresh has read the token's balance at every address
|
||||
// (doRefreshAndRender() in src/popup/index.js). Until then, an address with no
|
||||
// balance row for the token shows `quantity unknown` for it, not 0.0000.
|
||||
function trackToken(token) {
|
||||
state.trackedTokens.push({ ...token, balanceNotFetched: true });
|
||||
}
|
||||
|
||||
function balanceLinesForAddress(addr, trackedTokens, showZero) {
|
||||
let html = balanceLine(
|
||||
nativeCurrency(),
|
||||
@@ -452,7 +439,7 @@ function balanceLinesForAddress(addr, trackedTokens, showZero) {
|
||||
html += balanceLine(
|
||||
t.symbol,
|
||||
bal,
|
||||
getPrice(t.address),
|
||||
getPrice(t.symbol),
|
||||
t.address.toLowerCase(),
|
||||
);
|
||||
seen.add(t.address.toLowerCase());
|
||||
@@ -460,17 +447,10 @@ function balanceLinesForAddress(addr, trackedTokens, showZero) {
|
||||
if (showZero && trackedTokens) {
|
||||
for (const t of trackedTokens) {
|
||||
if (seen.has(t.address.toLowerCase())) continue;
|
||||
// A token that the spoof rule refuses has no stored balance, and
|
||||
// gets no zero row either.
|
||||
if (
|
||||
isSpoofedSymbol(t.symbol, t.address, currentNetwork().chainId)
|
||||
) {
|
||||
continue;
|
||||
}
|
||||
html += balanceLine(
|
||||
t.symbol,
|
||||
t.balanceNotFetched ? null : 0,
|
||||
getPrice(t.address),
|
||||
0,
|
||||
getPrice(t.symbol),
|
||||
t.address.toLowerCase(),
|
||||
);
|
||||
}
|
||||
@@ -849,7 +829,6 @@ module.exports = {
|
||||
flashCopyFeedback,
|
||||
balanceLine,
|
||||
balanceLinesForAddress,
|
||||
trackToken,
|
||||
addressHoldsFunds,
|
||||
keyMaterialName,
|
||||
unknownableAmount,
|
||||
|
||||
+2
-30
@@ -44,7 +44,6 @@ const {
|
||||
fetchRecentTransactions,
|
||||
filterTransactions,
|
||||
} = require("../../shared/transactions");
|
||||
const { storedNetworkIs } = require("../../shared/storedSettings");
|
||||
const { log } = require("../../shared/log");
|
||||
|
||||
function findActiveAddr() {
|
||||
@@ -184,7 +183,6 @@ async function loadHomeTxs(ctx) {
|
||||
}
|
||||
if (allAddresses.length === 0) return;
|
||||
|
||||
const networkId = state.networkId;
|
||||
const filters = {
|
||||
hideSpoofedSymbols: state.hideSpoofedSymbols,
|
||||
hideLowHolderTokens: state.hideLowHolderTokens,
|
||||
@@ -204,15 +202,6 @@ async function loadHomeTxs(ctx) {
|
||||
);
|
||||
const results = await Promise.all(fetches);
|
||||
|
||||
// If the network changed during the lookups, nothing is saved or
|
||||
// drawn. See src/shared/storedSettings.js.
|
||||
if (
|
||||
state.networkId !== networkId ||
|
||||
!(await storedNetworkIs(networkId))
|
||||
) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Merge, deduplicate by hash, filter, sort, take 25
|
||||
const seen = new Set();
|
||||
let merged = [];
|
||||
@@ -226,24 +215,14 @@ async function loadHomeTxs(ctx) {
|
||||
|
||||
const filtered = filterTransactions(merged, filters);
|
||||
|
||||
// Persist any newly discovered fraud contracts, inside the save and
|
||||
// holding the lock. Nothing is added unless this page and the stored
|
||||
// record both still name the request's network.
|
||||
// Persist any newly discovered fraud contracts
|
||||
if (filtered.newFraudContracts.length > 0) {
|
||||
let saved = false;
|
||||
await saveState((stored) => {
|
||||
if (state.networkId !== networkId) return false;
|
||||
if (stored.networkId !== networkId) return false;
|
||||
for (const addr of filtered.newFraudContracts) {
|
||||
if (!state.fraudContracts.includes(addr)) {
|
||||
state.fraudContracts.push(addr);
|
||||
}
|
||||
}
|
||||
saved = true;
|
||||
});
|
||||
// If the network changed while the save waited for the lock,
|
||||
// nothing is drawn.
|
||||
if (!saved) return;
|
||||
await saveState();
|
||||
}
|
||||
|
||||
merged = filtered.transactions;
|
||||
@@ -255,13 +234,6 @@ async function loadHomeTxs(ctx) {
|
||||
// src/popup/index.js.
|
||||
if (ctx.pageClosed.aborted) return;
|
||||
log.errorf("loadHomeTxs failed:", e.message);
|
||||
// If the network changed, the failure is not shown.
|
||||
if (
|
||||
state.networkId !== networkId ||
|
||||
!(await storedNetworkIs(networkId))
|
||||
) {
|
||||
return;
|
||||
}
|
||||
const list = $("home-tx-list");
|
||||
if (list) {
|
||||
list.innerHTML =
|
||||
|
||||
+4
-16
@@ -12,7 +12,7 @@ const {
|
||||
goBack,
|
||||
tokenSourcesByChainId,
|
||||
} = require("./helpers");
|
||||
const { state, currentAddress, currentNetwork } = require("../../shared/state");
|
||||
const { state, currentAddress } = require("../../shared/state");
|
||||
let ctx;
|
||||
const { getProvider } = require("../../shared/balances");
|
||||
const { resolveTokenDecimals } = require("../../shared/approvalAmount");
|
||||
@@ -154,9 +154,7 @@ function renderSendTokenSelect(addr) {
|
||||
// out. Its token's own screen can still send it: there
|
||||
// state.selectedToken picks the token, not this list.
|
||||
if (isBelowOneMillionth(t.balance)) continue;
|
||||
if (isSpoofedSymbol(t.symbol, t.address, currentNetwork().chainId)) {
|
||||
continue;
|
||||
}
|
||||
if (isSpoofedSymbol(t.symbol, t.address)) continue;
|
||||
if (fraudSet.has(t.address.toLowerCase())) continue;
|
||||
// An unknown holder count does not withhold a token the user holds:
|
||||
// only a count the explorer actually reported as below the threshold
|
||||
@@ -200,21 +198,13 @@ function renderSendTokenSelect(addr) {
|
||||
// null rather than "0": this screen states it as unknown, as the confirmation
|
||||
// screen does, and Max fills nothing in for it. Only a stored quantity is
|
||||
// withdrawn: the "0" for a token that has no row at all is an absence of
|
||||
// holdings, which is true at every scale. A token with no row whose tracked
|
||||
// record carries `balanceNotFetched` gets null instead, because no refresh has
|
||||
// read its balance.
|
||||
// holdings, which is true at every scale.
|
||||
function tokenBalanceAndDecimals(addr, token) {
|
||||
const tb = (addr.tokenBalances || []).find(
|
||||
(t) => t.address.toLowerCase() === token.toLowerCase(),
|
||||
);
|
||||
const tokenDecimals = resolveTokenDecimals(token, tokenSourcesByChainId());
|
||||
if (!tb) {
|
||||
const tracked = state.trackedTokens.find(
|
||||
(t) => t.address.toLowerCase() === token.toLowerCase(),
|
||||
);
|
||||
const notRead = tracked && tracked.balanceNotFetched;
|
||||
return { tokenBalance: notRead ? null : "0", tokenDecimals };
|
||||
}
|
||||
if (!tb) return { tokenBalance: "0", tokenDecimals };
|
||||
if (tokenDecimals === null) return { tokenBalance: null, tokenDecimals };
|
||||
return { tokenBalance: tb.balance ?? null, tokenDecimals };
|
||||
}
|
||||
@@ -240,7 +230,6 @@ function updateSendBalance() {
|
||||
token,
|
||||
addr.tokenBalances,
|
||||
state.trackedTokens,
|
||||
currentNetwork().chainId,
|
||||
);
|
||||
// A null balance is a holding whose scale is unknown. Saying a figure
|
||||
// for it would be a claim about the amount, so it reads as the
|
||||
@@ -396,7 +385,6 @@ function init(_ctx) {
|
||||
token,
|
||||
addr.tokenBalances,
|
||||
state.trackedTokens,
|
||||
currentNetwork().chainId,
|
||||
);
|
||||
({ tokenDecimals } = tokenBalanceAndDecimals(addr, token));
|
||||
}
|
||||
|
||||
@@ -44,17 +44,6 @@ let ctx;
|
||||
let versionClickCount = 0;
|
||||
let versionClickTimer = null;
|
||||
|
||||
// The network that Settings was last drawn for. A follow of a switch saved
|
||||
// elsewhere sets `state` to the new network first. Settings is drawn again only
|
||||
// once the follow's write returns. So both "Save" buttons take this network,
|
||||
// not the one in `state`.
|
||||
let shownNetwork = null;
|
||||
|
||||
// Each endpoint "Save" counts its taps here, under the field that it stores.
|
||||
// Once the user taps the same "Save" again, the earlier tap shows no flash
|
||||
// message. The earlier tap stores its URL only if its write had already begun.
|
||||
const saveTaps = { rpcUrl: 0, blockscoutUrl: 0 };
|
||||
|
||||
// One row per site origin, however many addresses it appears under, each with
|
||||
// an [x] that hands it to onRemove.
|
||||
function renderSiteList(containerId, origins, onRemove) {
|
||||
@@ -210,7 +199,6 @@ function renderWalletListSettings() {
|
||||
}
|
||||
|
||||
function show() {
|
||||
shownNetwork = currentNetwork();
|
||||
$("settings-rpc").value = state.rpcUrl;
|
||||
$("settings-blockscout").value = state.blockscoutUrl;
|
||||
$("settings-network").value = state.networkId;
|
||||
@@ -318,7 +306,6 @@ function showNewSettings() {
|
||||
state.checkRecipientsOnEtherscan;
|
||||
if (state.currentView === "settings") {
|
||||
markViewRendered("settings");
|
||||
shownNetwork = currentNetwork();
|
||||
$("settings-network").value = state.networkId;
|
||||
$("settings-rpc").value = state.rpcUrl;
|
||||
$("settings-blockscout").value = state.blockscoutUrl;
|
||||
@@ -332,70 +319,17 @@ function showNewSettings() {
|
||||
updateDebugBanner(state.currentView);
|
||||
}
|
||||
|
||||
// Saves `url` as `field` ("rpcUrl" or "blockscoutUrl") of the network
|
||||
// `networkId`, the one that Settings showed when the user tapped "Save". The
|
||||
// URL is set in `state` inside the save, holding the lock. So the page cannot
|
||||
// follow a switch saved elsewhere (followStoredSettings() in
|
||||
// src/popup/index.js) between setting the URL and writing it. If the active
|
||||
// network is no longer `networkId`, on this page or in the stored record,
|
||||
// nothing is saved. The flash message then says that the network changed.
|
||||
//
|
||||
// The save writes only the fields that differ from what this page last saved.
|
||||
// Another page may have stored a different URL since then. So `url` is set in
|
||||
// the stored record too. "Saved." then means that the stored record holds
|
||||
// `url`.
|
||||
//
|
||||
// `input` is the id of the input that the user typed `url` in. When another
|
||||
// page changes the network, "Use Blockscout" or "Check recipients on
|
||||
// Etherscan", this page draws Settings again. A redraw during the endpoint
|
||||
// check puts the URL from `state` back in the input. So if the input no longer
|
||||
// shows `url`, nothing is saved. The flash message then says that the URL was
|
||||
// changed during the check. The save compares the input and sets `url` in
|
||||
// `state` in one step. So a redraw after the comparison shows `url`.
|
||||
//
|
||||
// `tap` is the number of the "Save" tap that checked `url`. If the user taps
|
||||
// the same "Save" again before this save holds the lock, nothing is stored. If
|
||||
// the user taps the same "Save" again before the write ends, no flash message
|
||||
// is shown.
|
||||
async function saveEndpoint(field, input, url, networkId, tap) {
|
||||
let refused = false;
|
||||
let inputChanged = false;
|
||||
await saveState((stored) => {
|
||||
if (saveTaps[field] !== tap) return false;
|
||||
refused =
|
||||
state.networkId !== networkId || stored.networkId !== networkId;
|
||||
inputChanged = $(input).value.trim() !== url;
|
||||
if (refused || inputChanged) return false;
|
||||
state[field] = url;
|
||||
stored[field] = url;
|
||||
});
|
||||
if (saveTaps[field] !== tap) return;
|
||||
if (refused) {
|
||||
showFlash("The URL was not saved because the network changed.");
|
||||
} else if (inputChanged) {
|
||||
showFlash(
|
||||
"The URL was not saved because it was changed during the check.",
|
||||
);
|
||||
} else {
|
||||
showFlash("Saved.");
|
||||
}
|
||||
}
|
||||
|
||||
function init(_ctx) {
|
||||
ctx = _ctx;
|
||||
deleteWallet.init(ctx);
|
||||
showPhrase.init();
|
||||
|
||||
$("btn-save-rpc").addEventListener("click", async () => {
|
||||
saveTaps.rpcUrl++;
|
||||
const tap = saveTaps.rpcUrl;
|
||||
const url = $("settings-rpc").value.trim();
|
||||
if (!url) {
|
||||
showFlash("Please enter an RPC URL.");
|
||||
return;
|
||||
}
|
||||
// The URL is for the network that Settings shows when "Save" is tapped.
|
||||
const net = shownNetwork;
|
||||
showFlash("Testing endpoint...");
|
||||
try {
|
||||
const resp = await debugFetch(url, {
|
||||
@@ -409,13 +343,12 @@ function init(_ctx) {
|
||||
}),
|
||||
});
|
||||
const json = await resp.json();
|
||||
// The user has tapped this "Save" again since the check began.
|
||||
if (tap !== saveTaps.rpcUrl) return;
|
||||
if (json.error) {
|
||||
log.errorf("RPC validation error:", json.error);
|
||||
showFlash("Endpoint returned an error.");
|
||||
return;
|
||||
}
|
||||
const net = currentNetwork();
|
||||
if (json.result !== net.chainId) {
|
||||
showFlash("Wrong network: expected " + net.name + ".");
|
||||
return;
|
||||
@@ -424,7 +357,6 @@ function init(_ctx) {
|
||||
// Cancelled by the popup closing, not failed: see pageClosed in
|
||||
// src/popup/index.js.
|
||||
if (ctx.pageClosed.aborted) return;
|
||||
if (tap !== saveTaps.rpcUrl) return;
|
||||
// Not the error's message: fetch puts the whole URL, password and
|
||||
// key included, in the message of the error it throws for a URL
|
||||
// with a user name and password or one it cannot parse.
|
||||
@@ -432,41 +364,34 @@ function init(_ctx) {
|
||||
showFlash("Could not reach endpoint.");
|
||||
return;
|
||||
}
|
||||
await saveEndpoint("rpcUrl", "settings-rpc", url, net.id, tap);
|
||||
state.rpcUrl = url;
|
||||
await saveState();
|
||||
showFlash("Saved.");
|
||||
});
|
||||
|
||||
$("btn-save-blockscout").addEventListener("click", async () => {
|
||||
saveTaps.blockscoutUrl++;
|
||||
const tap = saveTaps.blockscoutUrl;
|
||||
const url = $("settings-blockscout").value.trim();
|
||||
if (!url) {
|
||||
showFlash("Please enter a Blockscout API URL.");
|
||||
return;
|
||||
}
|
||||
const net = shownNetwork;
|
||||
showFlash("Testing endpoint...");
|
||||
try {
|
||||
const resp = await debugFetch(url + "/stats");
|
||||
if (tap !== saveTaps.blockscoutUrl) return;
|
||||
if (!resp.ok) {
|
||||
showFlash("Endpoint returned HTTP " + resp.status + ".");
|
||||
return;
|
||||
}
|
||||
} catch {
|
||||
if (ctx.pageClosed.aborted) return;
|
||||
if (tap !== saveTaps.blockscoutUrl) return;
|
||||
// Not the error's message, as for the RPC check above.
|
||||
log.errorf("Blockscout validation failed:", urlOrigin(url));
|
||||
showFlash("Could not reach endpoint.");
|
||||
return;
|
||||
}
|
||||
await saveEndpoint(
|
||||
"blockscoutUrl",
|
||||
"settings-blockscout",
|
||||
url,
|
||||
net.id,
|
||||
tap,
|
||||
);
|
||||
state.blockscoutUrl = url;
|
||||
await saveState();
|
||||
showFlash("Saved.");
|
||||
});
|
||||
|
||||
// Each change is made inside the save, holding the lock. So
|
||||
|
||||
@@ -1,16 +1,8 @@
|
||||
const {
|
||||
$,
|
||||
showView,
|
||||
showFlash,
|
||||
escapeHtml,
|
||||
goBack,
|
||||
trackToken,
|
||||
} = require("./helpers");
|
||||
const { $, showView, showFlash, escapeHtml, goBack } = require("./helpers");
|
||||
const { getTopTokens } = require("../../shared/tokenList");
|
||||
const { state, saveState, currentNetwork } = require("../../shared/state");
|
||||
const { lookupTokenInfo } = require("../../shared/balances");
|
||||
const { isScamAddress } = require("../../shared/scamlist");
|
||||
const { isSpoofedSymbol } = require("../../shared/symbolSpoof");
|
||||
const { log } = require("../../shared/log");
|
||||
|
||||
let ctx;
|
||||
@@ -51,7 +43,7 @@ function renderTop10() {
|
||||
decimals: parseInt(btn.dataset.decimals, 10),
|
||||
name: btn.dataset.name || btn.dataset.symbol,
|
||||
};
|
||||
trackToken(token);
|
||||
state.trackedTokens.push(token);
|
||||
await saveState();
|
||||
showFlash("Added " + token.symbol);
|
||||
renderTop10();
|
||||
@@ -118,7 +110,7 @@ function init(_ctx) {
|
||||
decimals: parseInt(opt.dataset.decimals, 10),
|
||||
name: opt.dataset.name || opt.dataset.symbol,
|
||||
};
|
||||
trackToken(token);
|
||||
state.trackedTokens.push(token);
|
||||
await saveState();
|
||||
showFlash("Added " + token.symbol);
|
||||
renderTop10();
|
||||
@@ -163,18 +155,8 @@ function init(_ctx) {
|
||||
);
|
||||
return;
|
||||
}
|
||||
// The balance list never shows a token that the spoof rule
|
||||
// refuses, so such a token is not tracked. The rule never refuses
|
||||
// a bundled token, so the "Top tokens:" buttons and the top 100
|
||||
// dropdown need no such check.
|
||||
if (isSpoofedSymbol(info.symbol, addr, chainId)) {
|
||||
showFlash("Not added: this token fakes a known symbol.");
|
||||
infoEl.textContent = "";
|
||||
infoEl.style.visibility = "hidden";
|
||||
return;
|
||||
}
|
||||
log.infof("Adding token", info.symbol, addr);
|
||||
trackToken({
|
||||
state.trackedTokens.push({
|
||||
address: addr,
|
||||
symbol: info.symbol,
|
||||
decimals: info.decimals,
|
||||
|
||||
@@ -311,21 +311,10 @@ function populateOnChainDetails(txData, chainId) {
|
||||
}
|
||||
}
|
||||
|
||||
// Whether TransactionDetail still holds the transaction with `txHash` on
|
||||
// `chainId`. Opening another transaction replaces the one TransactionDetail
|
||||
// holds. A visit to Settings does not.
|
||||
function holdsTransaction(txHash, chainId) {
|
||||
const tx = state.viewData.tx;
|
||||
return tx?.hash === txHash && tx?.chainId === chainId;
|
||||
}
|
||||
|
||||
// Reads the block, network details and calldata from Blockscout, and decodes
|
||||
// the calldata. While the stored "Use Blockscout" is off, Blockscout is not
|
||||
// asked. An answer that lands after the setting went off is dropped
|
||||
// (src/shared/storedSettings.js). Either way none of them is shown.
|
||||
//
|
||||
// Blockscout can answer after the user has opened another transaction. That
|
||||
// answer is dropped.
|
||||
async function loadFullTxDetails(txHash, chainId) {
|
||||
if (!(await storedSettingIsOn("useBlockscout"))) return;
|
||||
const section = $("tx-detail-calldata-section");
|
||||
@@ -344,7 +333,6 @@ async function loadFullTxDetails(txHash, chainId) {
|
||||
if (!resp.ok) return;
|
||||
const txData = await resp.json();
|
||||
if (!(await storedSettingIsOn("useBlockscout"))) return;
|
||||
if (!holdsTransaction(txHash, chainId)) return;
|
||||
|
||||
// Populate on-chain detail fields (block, nonce, gas, fee)
|
||||
populateOnChainDetails(txData, chainId);
|
||||
|
||||
@@ -29,7 +29,7 @@
|
||||
// string, and a token the user added by hand carries whatever lookupTokenInfo()
|
||||
// got back, so the accepted types are enumerated rather than coerced.
|
||||
const { toDecimals } = require("./transferAmount");
|
||||
const { bundledToken } = require("./tokenList");
|
||||
const { TOKEN_BY_ADDRESS } = require("./tokenList");
|
||||
const { isSpoofedSymbol } = require("./symbolSpoof");
|
||||
|
||||
// Every decimals the explorer reported for this contract, across all the
|
||||
@@ -53,14 +53,12 @@ function explorerDecimals(lower, wallets) {
|
||||
}
|
||||
|
||||
// The decimals to render a token amount with, or null when nothing knows.
|
||||
// `sources` is { chainId, trackedTokens, wallets }. `chainId` is the chain id
|
||||
// of the token's network. The bundled list is read only when that network is
|
||||
// Ethereum Mainnet. `trackedTokens` and `wallets` are shaped as on `state`.
|
||||
// `sources` is { trackedTokens, wallets }, both shaped as they are on `state`.
|
||||
function resolveTokenDecimals(tokenAddress, sources) {
|
||||
const lower = (tokenAddress || "").toLowerCase();
|
||||
if (!lower) return null;
|
||||
|
||||
const bundled = bundledToken(lower, sources && sources.chainId);
|
||||
const bundled = TOKEN_BY_ADDRESS.get(lower);
|
||||
if (bundled) {
|
||||
const d = toDecimals(bundled.decimals);
|
||||
if (d !== null) return d;
|
||||
@@ -102,19 +100,18 @@ function explorerSymbol(lower, wallets) {
|
||||
// explorer reported: the same sources and the same precedence
|
||||
// resolveTokenDecimals() uses, so a token's name and its scale are drawn from
|
||||
// the same place and the two can no longer disagree about which sources they
|
||||
// trust. `sources` is as for resolveTokenDecimals().
|
||||
// trust. `sources` is { trackedTokens, wallets }, shaped as on `state`.
|
||||
//
|
||||
// A tracked or explorer-reported symbol is attacker-influenced text, so it is
|
||||
// held to the spoof rule (symbolSpoof.js): a candidate that the rule calls a
|
||||
// spoof is refused and the next source tried, so resolving a symbol never
|
||||
// becomes a new way to claim a known ticker. The bundled list is the wallet's
|
||||
// own data and is trusted as it is.
|
||||
// held to the spoof rule (symbolSpoof.js): a candidate that wears a bundled or
|
||||
// native ticker from a contract not entitled to it is refused and the next
|
||||
// source tried, so resolving a symbol never becomes a new way to claim a known
|
||||
// ticker. The bundled list is the wallet's own data and is trusted as it is.
|
||||
function resolveTokenSymbol(tokenAddress, sources) {
|
||||
const lower = (tokenAddress || "").toLowerCase();
|
||||
if (!lower) return null;
|
||||
|
||||
const chainId = sources && sources.chainId;
|
||||
const bundled = bundledToken(lower, chainId);
|
||||
const bundled = TOKEN_BY_ADDRESS.get(lower);
|
||||
if (bundled && bundled.symbol) return bundled.symbol;
|
||||
|
||||
const tracked = ((sources && sources.trackedTokens) || []).find(
|
||||
@@ -126,7 +123,7 @@ function resolveTokenSymbol(tokenAddress, sources) {
|
||||
if (reported) candidates.push(reported);
|
||||
|
||||
for (const symbol of candidates) {
|
||||
if (!isSpoofedSymbol(symbol, tokenAddress, chainId)) return symbol;
|
||||
if (!isSpoofedSymbol(symbol, tokenAddress)) return symbol;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
+11
-40
@@ -17,7 +17,7 @@ const { ERC20_ABI } = require("./constants");
|
||||
const { NETWORKS } = require("./networks");
|
||||
const { log, debugFetch, urlOrigin } = require("./log");
|
||||
const { deriveAddressFromXpub } = require("./wallet");
|
||||
const { bundledToken } = require("./tokenList");
|
||||
const { TOKEN_BY_ADDRESS } = require("./tokenList");
|
||||
const { LOW_HOLDER_THRESHOLD, parseHoldersCount } = require("./holders");
|
||||
const { isSpoofedSymbol } = require("./symbolSpoof");
|
||||
const { toDecimals } = require("./transferAmount");
|
||||
@@ -106,9 +106,6 @@ function rawUnits(value) {
|
||||
// balance is read through the RPC endpoint instead, and its row here gives that
|
||||
// entry its holder count and `decimals` (fetchTrackedTokenBalances()).
|
||||
//
|
||||
// `chainId` is the chain id of the network `blockscoutUrl` serves. The known
|
||||
// token list is used only when that network is Ethereum Mainnet.
|
||||
//
|
||||
// `decimals` and `balance` are each null when the answer is unknown, the same
|
||||
// way `holders` already is. Absence is never filled in here: this is the
|
||||
// upstream of every screen that displays a token amount, so a value invented
|
||||
@@ -120,7 +117,6 @@ async function fetchTokenBalances(
|
||||
address,
|
||||
blockscoutUrl,
|
||||
trackedTokens,
|
||||
chainId,
|
||||
signal,
|
||||
) {
|
||||
if (!(await storedSettingIsOn("useBlockscout"))) return [];
|
||||
@@ -179,10 +175,7 @@ async function fetchTokenBalances(
|
||||
// either way: copying another source into it would make
|
||||
// explorerDecimals()'s disagreement check compare something other
|
||||
// than explorer values.
|
||||
const known = resolveTokenDecimals(tokenAddr, {
|
||||
chainId,
|
||||
trackedTokens,
|
||||
});
|
||||
const known = resolveTokenDecimals(tokenAddr, { trackedTokens });
|
||||
const scale = known !== null ? known : decimals;
|
||||
// null is a holding of an amount that cannot be stated, which is
|
||||
// not the same as a holding of zero, and must never render as one.
|
||||
@@ -198,7 +191,7 @@ async function fetchTokenBalances(
|
||||
// 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 = bundledToken(tokenAddr, chainId) !== null;
|
||||
const isKnown = TOKEN_BY_ADDRESS.has(tokenAddr);
|
||||
const isTracked = trackedSet.has(tokenAddr);
|
||||
const hasEnoughHolders = holders >= LOW_HOLDER_THRESHOLD;
|
||||
|
||||
@@ -209,9 +202,7 @@ async function fetchTokenBalances(
|
||||
// Every row here is an ERC-20 the explorer reported, so it has a
|
||||
// contract address; the native ETH balance is fetched over RPC in
|
||||
// refreshBalances and never passes through this loop.
|
||||
if (isSpoofedSymbol(item.token.symbol, tokenAddr, chainId)) {
|
||||
continue;
|
||||
}
|
||||
if (isSpoofedSymbol(item.token.symbol, tokenAddr)) continue;
|
||||
|
||||
balances.push({
|
||||
address: item.token.address_hash,
|
||||
@@ -256,24 +247,19 @@ async function fetchTokenBalances(
|
||||
// it has none. The failure is logged. A balance of zero gets no entry, as a
|
||||
// zero Blockscout reports gets none: the balance lists take a tracked token's
|
||||
// zero from the tracked list. A token whose symbol the spoof rule refuses gets
|
||||
// no entry either, as in fetchTokenBalances(), and its balance is not read.
|
||||
// no entry either, as in fetchTokenBalances().
|
||||
//
|
||||
// Resolves with `rows`, the entries, and `unread`, the tracked tokens whose
|
||||
// balance was not read, as lowercased contract addresses. A token is unread
|
||||
// when the spoof rule refuses it or its balanceOf fails.
|
||||
//
|
||||
// `chainId` and `signal` are as for fetchTokenBalances().
|
||||
// `signal` is as for fetchTokenBalances().
|
||||
async function fetchTrackedTokenBalances(
|
||||
provider,
|
||||
address,
|
||||
trackedTokens,
|
||||
previous,
|
||||
explorerRequest,
|
||||
chainId,
|
||||
signal,
|
||||
) {
|
||||
const listed = trackedTokens.filter(
|
||||
(token) => !isSpoofedSymbol(token.symbol, token.address, chainId),
|
||||
(token) => !isSpoofedSymbol(token.symbol, token.address),
|
||||
);
|
||||
// Each token's balanceOf answer, or null where it failed.
|
||||
const balances = await Promise.all(
|
||||
@@ -302,16 +288,12 @@ async function fetchTrackedTokenBalances(
|
||||
const reported = explorerRows ?? previous;
|
||||
|
||||
const rows = [];
|
||||
const unread = trackedTokens
|
||||
.filter((token) => !listed.includes(token))
|
||||
.map((token) => token.address.toLowerCase());
|
||||
listed.forEach((token, i) => {
|
||||
const lower = token.address.toLowerCase();
|
||||
const entryIn = (list) =>
|
||||
list.find((row) => String(row.address).toLowerCase() === lower);
|
||||
const raw = balances[i];
|
||||
if (raw === null) {
|
||||
unread.push(lower);
|
||||
const kept = entryIn(previous) || entryIn(explorerRows || []);
|
||||
if (kept) rows.push(kept);
|
||||
return;
|
||||
@@ -319,7 +301,7 @@ async function fetchTrackedTokenBalances(
|
||||
if (raw === 0n) return;
|
||||
const entry = entryIn(reported);
|
||||
const decimals = entry ? entry.decimals : null;
|
||||
const known = resolveTokenDecimals(lower, { chainId, trackedTokens });
|
||||
const known = resolveTokenDecimals(lower, { trackedTokens });
|
||||
const scale = known !== null ? known : decimals;
|
||||
rows.push({
|
||||
address: token.address,
|
||||
@@ -332,15 +314,12 @@ async function fetchTrackedTokenBalances(
|
||||
holders: entry ? entry.holders : null,
|
||||
});
|
||||
});
|
||||
return { rows, unread };
|
||||
return rows;
|
||||
}
|
||||
|
||||
// Fetch ETH balances, ENS names, and ERC-20 token balances for all addresses.
|
||||
// `trackedTokens` are the tokens tracked on the active network. `signal` is as
|
||||
// for fetchTokenBalances().
|
||||
//
|
||||
// Resolves with the lowercased contract addresses of the tracked tokens whose
|
||||
// balance it read at every address.
|
||||
async function refreshBalances(
|
||||
wallets,
|
||||
rpcUrl,
|
||||
@@ -351,11 +330,8 @@ async function refreshBalances(
|
||||
) {
|
||||
log.debugf("refreshBalances start, rpc:", urlOrigin(rpcUrl));
|
||||
const provider = getProvider(rpcUrl, networkId);
|
||||
const { chainId } = requireNetworkId(networkId);
|
||||
const tracked = trackedTokens || [];
|
||||
const trackedSet = new Set(tracked.map((t) => t.address.toLowerCase()));
|
||||
// The tracked tokens whose balance was not read at some address.
|
||||
const unread = new Set();
|
||||
const updates = [];
|
||||
|
||||
for (const wallet of wallets) {
|
||||
@@ -417,7 +393,6 @@ async function refreshBalances(
|
||||
addr.address,
|
||||
blockscoutUrl,
|
||||
tracked,
|
||||
chainId,
|
||||
signal,
|
||||
);
|
||||
updates.push(
|
||||
@@ -428,18 +403,15 @@ async function refreshBalances(
|
||||
tracked,
|
||||
previous,
|
||||
explorerRequest,
|
||||
chainId,
|
||||
signal,
|
||||
),
|
||||
explorerRequest,
|
||||
]).then(([trackedResult, explorerRows]) => {
|
||||
for (const lower of trackedResult.unread) unread.add(lower);
|
||||
]).then(([trackedRows, explorerRows]) => {
|
||||
const untrackedRows = (explorerRows ?? previous).filter(
|
||||
(row) =>
|
||||
!trackedSet.has(String(row.address).toLowerCase()),
|
||||
);
|
||||
addr.tokenBalances =
|
||||
trackedResult.rows.concat(untrackedRows);
|
||||
addr.tokenBalances = trackedRows.concat(untrackedRows);
|
||||
log.debugf(
|
||||
"Token balances",
|
||||
addr.address,
|
||||
@@ -453,7 +425,6 @@ async function refreshBalances(
|
||||
|
||||
await Promise.all(updates);
|
||||
log.debugf("refreshBalances done");
|
||||
return [...trackedSet].filter((lower) => !unread.has(lower));
|
||||
}
|
||||
|
||||
// Drops the balance of each token not in `trackedTokens` from every address.
|
||||
|
||||
@@ -47,63 +47,12 @@ function clearPopupCaches() {
|
||||
// lock, so it is never switched while a follow of a switch saved elsewhere
|
||||
// waits for the lock (followStoredSettings() in src/popup/index.js): that
|
||||
// follow runs first, and this switch is made after it.
|
||||
//
|
||||
// The save writes only the fields that differ from what this page last saved.
|
||||
// When this page last saved a balance of "0", clearing that balance is no
|
||||
// change. So the switch also resets these fields in the stored record:
|
||||
//
|
||||
// - every address's balance and token balances;
|
||||
// - the time of the last balance refresh;
|
||||
// - the fraud contracts.
|
||||
//
|
||||
// A balance or a fraud contract that the background or another page stored
|
||||
// since this page's last save is then not kept under the new network
|
||||
// (https://git.eeqj.de/sneak/AutistMask/issues/653,
|
||||
// https://git.eeqj.de/sneak/AutistMask/issues/692).
|
||||
//
|
||||
// When the stored record is on another network, a switch saved elsewhere has
|
||||
// not reached this page yet. This page first takes that switch with
|
||||
// takeStoredNetwork() (state.js), as followStoredSettings() does. The switch to
|
||||
// `newNetworkId` is then made from the stored record's network. So every
|
||||
// network's list of tracked tokens in the stored record is kept
|
||||
// (https://git.eeqj.de/sneak/AutistMask/issues/701). When the stored record is
|
||||
// already on `newNetworkId`, the switch made from there only resets the
|
||||
// balances and caches.
|
||||
//
|
||||
// When the stored record is on this page's network, this page first takes the
|
||||
// stored `networkTrackedTokens` (takeStoredNetworkTrackedTokens() in state.js),
|
||||
// because another page's save may have changed a list this page holds.
|
||||
//
|
||||
// Before the switch, `state` takes the tracked tokens that another page stored
|
||||
// since this page's last save (takeStoredTrackedTokens() in state.js). The
|
||||
// switch then puts them away under the previous network, the network they were
|
||||
// added on.
|
||||
async function onChainSwitch(newNetworkId) {
|
||||
const {
|
||||
state,
|
||||
saveState,
|
||||
takeStoredNetwork,
|
||||
takeStoredTrackedTokens,
|
||||
takeStoredNetworkTrackedTokens,
|
||||
} = require("./state");
|
||||
const { state, saveState } = require("./state");
|
||||
let net = null;
|
||||
await saveState((stored) => {
|
||||
await saveState(() => {
|
||||
if (state.networkId === newNetworkId) return false;
|
||||
if (stored.networkId !== state.networkId) {
|
||||
takeStoredNetwork(stored);
|
||||
} else {
|
||||
takeStoredNetworkTrackedTokens(stored);
|
||||
}
|
||||
takeStoredTrackedTokens(stored);
|
||||
net = applyChainSwitchFields(state, newNetworkId);
|
||||
stored.lastBalanceRefresh = 0;
|
||||
stored.fraudContracts = [];
|
||||
for (const wallet of stored.wallets) {
|
||||
for (const addr of wallet.addresses) {
|
||||
addr.balance = "0";
|
||||
addr.tokenBalances = [];
|
||||
}
|
||||
}
|
||||
clearPopupCaches();
|
||||
});
|
||||
return net;
|
||||
|
||||
+19
-95
@@ -1,105 +1,31 @@
|
||||
// USD prices, read from Chainlink price feeds on Ethereum mainnet, with USD
|
||||
// formatting and value aggregation. The feeds are in src/shared/tokenList.js.
|
||||
// Price fetching with 5-minute cache, USD formatting, value aggregation.
|
||||
|
||||
const { Contract } = require("ethers");
|
||||
const { ETH_USD_FEED, PRICE_FEED_BY_ADDRESS } = require("./tokenList");
|
||||
const { getProvider } = require("./balances");
|
||||
const { getTopTokenPrices } = require("./tokenList");
|
||||
const { isBelowOneMillionth } = require("./amountDisplay");
|
||||
const { networkByChainId } = require("./networks");
|
||||
const { log } = require("./log");
|
||||
|
||||
const PRICE_CACHE_TTL = 300000; // 5 minutes
|
||||
|
||||
// A reading older than its feed's heartbeat plus this many seconds is no price.
|
||||
const STALE_MARGIN = 1800; // 30 minutes
|
||||
|
||||
const FEED_ABI = [
|
||||
"function latestRoundData() view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)",
|
||||
];
|
||||
|
||||
// USD prices: ether's under "ETH", each token's under its lowercased contract
|
||||
// address.
|
||||
const prices = {};
|
||||
let lastFetchedAt = 0;
|
||||
|
||||
// Reads the price of ether and of each token any address holds or the user
|
||||
// tracks, when that token has a feed. Mainnet only. The reads go to the RPC
|
||||
// endpoint as one batched request, at most every 5 minutes. A failed read is
|
||||
// logged, and that token then has no price.
|
||||
//
|
||||
// `signal`, passed by the popup, is aborted when the popup closes. A read that
|
||||
// fails once `signal` is aborted is not logged, because closing the popup
|
||||
// cancelled it.
|
||||
async function refreshPrices(signal) {
|
||||
const { state, currentNetwork } = require("./state");
|
||||
if (currentNetwork().id !== "mainnet") {
|
||||
async function refreshPrices() {
|
||||
// Testnet tokens have no real market value — skip price fetching
|
||||
// and clear any stale mainnet prices so the UI shows no USD values.
|
||||
const { currentNetwork } = require("./state");
|
||||
if (currentNetwork().isTestnet) {
|
||||
clearPrices();
|
||||
return;
|
||||
}
|
||||
const now = Date.now();
|
||||
if (now - lastFetchedAt < PRICE_CACHE_TTL) return;
|
||||
const feeds = new Map([["ETH", ETH_USD_FEED]]);
|
||||
for (const address of heldOrTrackedTokens(state)) {
|
||||
const feed = PRICE_FEED_BY_ADDRESS.get(address);
|
||||
if (feed) feeds.set(address, feed);
|
||||
}
|
||||
// ethers sends calls made together on one provider as one batch.
|
||||
const provider = getProvider(state.rpcUrl, state.networkId);
|
||||
const read = {};
|
||||
await Promise.all(
|
||||
[...feeds].map(async ([key, feed]) => {
|
||||
try {
|
||||
const contract = new Contract(feed.address, FEED_ABI, provider);
|
||||
const round = await contract.latestRoundData();
|
||||
const price = priceFromRound(round, feed, now);
|
||||
if (price === null) {
|
||||
log.warnf(
|
||||
"price feed reading is stale or not positive",
|
||||
key,
|
||||
);
|
||||
return;
|
||||
}
|
||||
read[key] = price;
|
||||
} catch (e) {
|
||||
if (signal?.aborted) return;
|
||||
log.errorf(
|
||||
"price feed read failed",
|
||||
key,
|
||||
e.shortMessage || e.message,
|
||||
);
|
||||
}
|
||||
}),
|
||||
);
|
||||
clearPrices();
|
||||
Object.assign(prices, read);
|
||||
const fetched = await getTopTokenPrices(25);
|
||||
Object.assign(prices, fetched);
|
||||
lastFetchedAt = now;
|
||||
} catch {
|
||||
// prices stay stale on error
|
||||
}
|
||||
|
||||
// The lowercased contract address of each token that any address holds or
|
||||
// that the user tracks.
|
||||
function heldOrTrackedTokens(state) {
|
||||
const addresses = new Set();
|
||||
for (const wallet of state.wallets) {
|
||||
for (const addr of wallet.addresses) {
|
||||
for (const token of addr.tokenBalances || []) {
|
||||
addresses.add(token.address.toLowerCase());
|
||||
}
|
||||
}
|
||||
}
|
||||
for (const token of state.trackedTokens || []) {
|
||||
addresses.add(token.address.toLowerCase());
|
||||
}
|
||||
return addresses;
|
||||
}
|
||||
|
||||
// The USD price in a feed's latestRoundData() result, or null when the answer
|
||||
// is not positive or was written longer ago than the feed's heartbeat plus
|
||||
// STALE_MARGIN. `now` is in milliseconds.
|
||||
function priceFromRound(round, feed, now) {
|
||||
const ageSeconds = now / 1000 - Number(round.updatedAt);
|
||||
if (ageSeconds > feed.heartbeat + STALE_MARGIN) return null;
|
||||
if (round.answer <= 0n) return null;
|
||||
return Number(round.answer) / 10 ** feed.decimals;
|
||||
}
|
||||
|
||||
// Clear all cached prices and reset the fetch timestamp so the
|
||||
@@ -111,15 +37,14 @@ function clearPrices() {
|
||||
lastFetchedAt = 0;
|
||||
}
|
||||
|
||||
// Return the USD price of the token at the contract address `token`, or of
|
||||
// ether when `token` is "ETH". The price is for the network with `chainId`, or
|
||||
// for the active network when no chain id is given. Returns null on testnet,
|
||||
// on a chain id that names no network, and for a token with no price.
|
||||
function getPrice(token, chainId) {
|
||||
// Return the USD price for a symbol on the network with `chainId`, or on the
|
||||
// active network when no chain id is given; null on testnet, on a chain id
|
||||
// that names no network, or for a symbol with no price.
|
||||
function getPrice(symbol, chainId) {
|
||||
const { currentNetwork } = require("./state");
|
||||
const network = chainId ? networkByChainId(chainId) : currentNetwork();
|
||||
if (!network || network.isTestnet) return null;
|
||||
return prices[token === "ETH" ? "ETH" : token.toLowerCase()] || null;
|
||||
return prices[symbol] || null;
|
||||
}
|
||||
|
||||
function formatUsd(amount) {
|
||||
@@ -137,7 +62,7 @@ function formatUsd(amount) {
|
||||
|
||||
// What an address is worth, as { usd, partial }.
|
||||
//
|
||||
// Only a token with a price feed has a price, so an address can hold real
|
||||
// Prices are fetched for the top 25 tokens only, so an address can hold real
|
||||
// assets this code has no price for. Adding up the priced ones and calling the
|
||||
// result the total states a number the holdings do not support: an address
|
||||
// holding nothing but unpriced tokens comes out at $0.00, which tells the user
|
||||
@@ -174,9 +99,8 @@ function getAddressValue(addr) {
|
||||
// nor make it incomplete. Anything that is not a number at all is not
|
||||
// a holding this can price either, and is left to the same rule.
|
||||
if (!(tokenBal > 0)) continue;
|
||||
const price = prices[token.address.toLowerCase()];
|
||||
if (price) {
|
||||
usd += tokenBal * price;
|
||||
if (prices[token.symbol]) {
|
||||
usd += tokenBal * prices[token.symbol];
|
||||
} else {
|
||||
partial = true;
|
||||
}
|
||||
|
||||
+20
-178
@@ -125,14 +125,11 @@ function currentNetwork() {
|
||||
return networkById(state.networkId);
|
||||
}
|
||||
|
||||
// `baseline` holds the persisted fields as this page held them when its last
|
||||
// loadState() finished, or when its last successful saveState() began.
|
||||
// takeStoredNetwork(), takeStoredTrackedTokens() and
|
||||
// takeStoredNetworkTrackedTokens() also write into it what this page has taken
|
||||
// from the stored record since then. `baseline` also lacks any
|
||||
// `balanceNotFetched` field that a balance refresh has deleted since
|
||||
// (clearBalanceNotFetched()). saveState() diffs the live state against
|
||||
// `baseline` to find only the fields THIS page changed since.
|
||||
// The persisted fields as this page held them when its last loadState()
|
||||
// finished, or when its last successful saveState() began, with any network
|
||||
// switch saved elsewhere that this page has taken since (takeStoredNetwork()).
|
||||
// saveState() diffs the live state against this to find only the fields THIS
|
||||
// page changed since.
|
||||
//
|
||||
// Deep-cloned, not a reference: callers mutate persisted objects and arrays
|
||||
// in place (state.wallets.push(...)), and a reference baseline would mutate
|
||||
@@ -404,51 +401,6 @@ function mergeNetworkEndpoints(base, ours, theirs) {
|
||||
return mergeMapByKey(base, ours, theirs, mergeEndpointEntry);
|
||||
}
|
||||
|
||||
// Merges one network's tracked tokens by contract address:
|
||||
//
|
||||
// - A token another page added or removed since this page's last save stays
|
||||
// added or removed.
|
||||
// - A token that this page and `theirs` both hold keeps this page's record.
|
||||
// - The result holds one record per contract address.
|
||||
//
|
||||
// mergeListByIdentity() keeps records that share an identity, on purpose, for
|
||||
// wallets. A contract address names one token, so this keeps one record for it.
|
||||
// Without that, a token that `ours` and `theirs` each hold twice comes back four
|
||||
// times, and each later merge multiplies it again.
|
||||
//
|
||||
// `theirs` takes this page's records first. mergeListByIdentity() would
|
||||
// otherwise log an error for two different records of one token.
|
||||
function mergeTrackedTokens(base, ours, theirs) {
|
||||
const contract = (token) => token.address.toLowerCase();
|
||||
const oursByContract = new Map(
|
||||
ours.map((token) => [contract(token), token]),
|
||||
);
|
||||
const merged = mergeListByIdentity(
|
||||
base,
|
||||
ours,
|
||||
theirs.map((token) => oursByContract.get(contract(token)) || token),
|
||||
contract,
|
||||
(baseToken, ourToken) => ourToken,
|
||||
);
|
||||
const byContract = new Map(merged.map((token) => [contract(token), token]));
|
||||
return [...byContract.values()];
|
||||
}
|
||||
|
||||
// Returns a copy of `stored.networkTrackedTokens` for when this page has not yet
|
||||
// taken the switch in `stored`. `page` is this page's state. A token that this
|
||||
// page tracked or removed since its last save is tracked or removed in the list
|
||||
// of `page.networkId`, by contract address.
|
||||
function networkTrackedTokensWithChange(stored, page) {
|
||||
return {
|
||||
...stored.networkTrackedTokens,
|
||||
[page.networkId]: mergeTrackedTokens(
|
||||
baseline.trackedTokens,
|
||||
page.trackedTokens,
|
||||
stored.networkTrackedTokens[page.networkId] || [],
|
||||
),
|
||||
};
|
||||
}
|
||||
|
||||
// Read-modify-write, merged per field, rather than one full-blob write.
|
||||
//
|
||||
// Every extension page (the toolbar popup, a dApp approval window) holds its
|
||||
@@ -489,27 +441,16 @@ function networkTrackedTokensWithChange(stored, page) {
|
||||
// comment at mergeEndpointEntry() for why the collision this closes is
|
||||
// milder than the other two.
|
||||
//
|
||||
// `trackedTokens` is merged by contract address (mergeTrackedTokens()) when this
|
||||
// page has changed it, so a token another page added or removed since this
|
||||
// page's last save stays added or removed. A token both lists hold keeps this
|
||||
// page's record. Two saves differ:
|
||||
//
|
||||
// - When the stored record is on another network than this page's, a save keeps
|
||||
// the stored `trackedTokens`. It merges this page's change into the list in
|
||||
// `networkTrackedTokens` for this page's network, by contract address.
|
||||
// - A save that switches networks writes this page's list whole. A switch in
|
||||
// Settings first merges that list by contract address
|
||||
// (takeStoredTrackedTokens()).
|
||||
//
|
||||
// Every other persisted field stays a whole-field diff:
|
||||
// `fraudContracts`/`viewStack` are arrays of scalars with no per-element
|
||||
// identity to merge by; `networkTrackedTokens` is diffed whole like `networkId`,
|
||||
// which a network switch moves together with it; `tokenHolderCache` is a map
|
||||
// shaped like the ones above, but nothing in src/ ever writes an entry into it —
|
||||
// it is only ever reset wholesale to `{}` (applyChainSwitchFields()) — so there
|
||||
// is no in-place mutation for a whole-field diff to collide with; `viewData` is
|
||||
// this page's own UI scratch space, not data another page has any reason to
|
||||
// share membership of.
|
||||
// `trackedTokens`/`fraudContracts`/`viewStack` are arrays of scalars with no
|
||||
// per-element identity to merge by; `networkTrackedTokens` is diffed whole like
|
||||
// `trackedTokens` and `networkId`, the two fields a network switch moves
|
||||
// together with it; `tokenHolderCache` is a map shaped like the ones above,
|
||||
// but nothing in src/ ever writes an entry into it — it is only ever reset
|
||||
// wholesale to `{}` (applyChainSwitchFields()) — so there is no in-place
|
||||
// mutation for a whole-field diff to collide with; `viewData` is this page's
|
||||
// own UI scratch space, not data another page has any reason to share
|
||||
// membership of.
|
||||
//
|
||||
// This does not make two pages that both change the SAME leaf concurrently
|
||||
// safe: last write wins on that one leaf, same as before. What it removes
|
||||
@@ -583,34 +524,6 @@ async function saveStateOnce(beforeWrite) {
|
||||
merged[key] = current[key];
|
||||
}
|
||||
}
|
||||
// When the merged record names a network other than this page's, this page
|
||||
// has not yet taken a switch saved elsewhere. This page's `trackedTokens`
|
||||
// is then the list of this page's network. The stored record keeps the
|
||||
// list of this page's network in `networkTrackedTokens`. So a token that
|
||||
// this page added or removed since its last save is added to or removed
|
||||
// from that stored list. The merged record keeps the stored `trackedTokens`
|
||||
// (https://git.eeqj.de/sneak/AutistMask/issues/701).
|
||||
if (merged.networkId !== current.networkId) {
|
||||
merged.trackedTokens = fresh.trackedTokens;
|
||||
merged.networkTrackedTokens = networkTrackedTokensWithChange(
|
||||
fresh,
|
||||
current,
|
||||
);
|
||||
} else if (
|
||||
baseline !== null &&
|
||||
baseline.networkId === current.networkId &&
|
||||
!deepEqual(current.trackedTokens, baseline.trackedTokens)
|
||||
) {
|
||||
// This page's network is the one it last saved on, and the stored
|
||||
// record is on it too, so all three lists are of one network. This
|
||||
// page's change goes into the stored list, and another page's add or
|
||||
// removal stays (https://git.eeqj.de/sneak/AutistMask/issues/717).
|
||||
merged.trackedTokens = mergeTrackedTokens(
|
||||
baseline.trackedTokens,
|
||||
current.trackedTokens,
|
||||
fresh.trackedTokens,
|
||||
);
|
||||
}
|
||||
merged.hasWallet = Boolean(merged.wallets && merged.wallets.length > 0);
|
||||
// Stamped on every write, never merged or diffed: the record that goes to
|
||||
// storage is in THIS build's shape whatever shape it was read in, which is
|
||||
@@ -678,10 +591,8 @@ function reportSaveFailure(err) {
|
||||
//
|
||||
// `beforeWrite`, when given, is called inside the lock with the stored record
|
||||
// as just read, before this page's state is compared against it. It may change
|
||||
// `state`, and this save writes that change. It may also change the stored
|
||||
// record. A field that this page did not change is then written as
|
||||
// `beforeWrite` left it. When it returns false, nothing is written; any other
|
||||
// return lets the save go ahead.
|
||||
// `state`, and this save writes that change. When it returns false, nothing is
|
||||
// written; any other return lets the save go ahead.
|
||||
function saveState(beforeWrite) {
|
||||
const turn = withLock("autistmask", () => saveStateOnce(beforeWrite));
|
||||
// Every failed save is reported, whether or not the caller awaited this
|
||||
@@ -691,81 +602,15 @@ function saveState(beforeWrite) {
|
||||
return turn;
|
||||
}
|
||||
|
||||
// Give this page the network switch held by `stored`, in `state` and in
|
||||
// `baseline` alike, as loadState() does with a whole record. `stored` is the
|
||||
// record that a save of this page has just read. followStoredSettings() in
|
||||
// src/popup/index.js and onChainSwitch() in src/shared/chainSwitch.js call this
|
||||
// from `beforeWrite`. The switch is then not this page's own change, even when
|
||||
// Give this page the network switch held by `stored`, a record a save of this
|
||||
// page has just read (followStoredSettings() in src/popup/index.js calls this
|
||||
// from `beforeWrite`), in `state` and in `baseline` alike, as loadState() does
|
||||
// with a whole record. The switch is then not this page's own change, even when
|
||||
// that save fails to write: a later switch back to the previous network still
|
||||
// differs from `baseline`, and is stored.
|
||||
//
|
||||
// A token that this page tracked or removed since its last save was tracked or
|
||||
// removed on this page's network before the switch. `state` keeps that change
|
||||
// in the list in `networkTrackedTokens` for that network, merged with the
|
||||
// stored list by contract address. `baseline` takes the stored list, so the
|
||||
// save stores the change (https://git.eeqj.de/sneak/AutistMask/issues/706).
|
||||
function takeStoredNetwork(stored) {
|
||||
const networkTrackedTokens = networkTrackedTokensWithChange(
|
||||
stored,
|
||||
rawState,
|
||||
);
|
||||
copyChainSwitchFields(rawState, stored);
|
||||
copyChainSwitchFields(baseline, structuredClone(stored));
|
||||
rawState.networkTrackedTokens = networkTrackedTokens;
|
||||
}
|
||||
|
||||
// Give this page the tracked tokens of `stored`, a record on this page's
|
||||
// network that a save of this page has just read (onChainSwitch() in
|
||||
// src/shared/chainSwitch.js calls this from `beforeWrite`):
|
||||
//
|
||||
// - A token that another page tracked or removed since this page's last save
|
||||
// is tracked or removed in `state` too.
|
||||
// - A token that this page tracked or removed since then stays as this page
|
||||
// has it.
|
||||
//
|
||||
// `baseline` takes the stored list, so the save stores the list in `state`
|
||||
// whenever the two differ.
|
||||
function takeStoredTrackedTokens(stored) {
|
||||
rawState.trackedTokens = mergeTrackedTokens(
|
||||
baseline.trackedTokens,
|
||||
rawState.trackedTokens,
|
||||
stored.trackedTokens,
|
||||
);
|
||||
baseline.trackedTokens = structuredClone(stored.trackedTokens);
|
||||
}
|
||||
|
||||
// Give `state` and `baseline` each their own copy of the stored
|
||||
// `networkTrackedTokens`. `stored` is a record on this page's network that a
|
||||
// save of this page has just read. onChainSwitch() in
|
||||
// src/shared/chainSwitch.js calls this from `beforeWrite`.
|
||||
function takeStoredNetworkTrackedTokens(stored) {
|
||||
rawState.networkTrackedTokens = structuredClone(
|
||||
stored.networkTrackedTokens,
|
||||
);
|
||||
baseline.networkTrackedTokens = structuredClone(
|
||||
stored.networkTrackedTokens,
|
||||
);
|
||||
}
|
||||
|
||||
// Deletes `balanceNotFetched` from each tracked token whose lowercased
|
||||
// contract address is in `addresses`. The field goes from `stored`, from
|
||||
// `state` and from `baseline` alike. `stored` is the record a save of this
|
||||
// page has just read (doRefreshAndRender() in src/popup/index.js calls this
|
||||
// from `beforeWrite`). So the deletion is not a change this page made to its
|
||||
// tracked tokens. Unless this page has changed its tracked tokens itself, the
|
||||
// save then writes the stored list with only the field gone.
|
||||
function clearBalanceNotFetched(stored, addresses) {
|
||||
for (const list of [
|
||||
stored.trackedTokens,
|
||||
rawState.trackedTokens,
|
||||
baseline.trackedTokens,
|
||||
]) {
|
||||
for (const token of list) {
|
||||
if (addresses.includes(token.address.toLowerCase())) {
|
||||
delete token.balanceNotFetched;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Rejects with StateUnusableError for a stored record this build cannot make
|
||||
@@ -814,9 +659,6 @@ module.exports = {
|
||||
saveState,
|
||||
onSaveFailure,
|
||||
takeStoredNetwork,
|
||||
takeStoredTrackedTokens,
|
||||
takeStoredNetworkTrackedTokens,
|
||||
clearBalanceNotFetched,
|
||||
loadState,
|
||||
currentAddress,
|
||||
currentNetwork,
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
// Reads "Use Blockscout", "Check recipients on Etherscan" or the active network
|
||||
// from the stored profile.
|
||||
// Reads "Use Blockscout" or "Check recipients on Etherscan" from the stored
|
||||
// profile.
|
||||
//
|
||||
// Before each request that sends the user's data to Blockscout or Etherscan, the
|
||||
// wallet reads that service's setting from storage. The wallet reads the setting
|
||||
@@ -7,11 +7,6 @@
|
||||
// made, and an answer that lands after the setting went off is dropped. A page's
|
||||
// own copy of the setting is not used, because another page may have just
|
||||
// changed it.
|
||||
//
|
||||
// Before asking Blockscout for the transaction history, a screen remembers
|
||||
// which network is active. If another network is active on the page or in
|
||||
// storage when the answer lands, the screen drops the answer. A switch saved
|
||||
// elsewhere reaches storage first and the page later.
|
||||
|
||||
const { storageGet } = require("./browserApi");
|
||||
const { normalizePersisted } = require("./persistedState");
|
||||
@@ -29,15 +24,4 @@ async function storedSettingIsOn(name) {
|
||||
}
|
||||
}
|
||||
|
||||
// Whether `networkId` is the active network in the stored profile. A failed
|
||||
// read counts as no.
|
||||
async function storedNetworkIs(networkId) {
|
||||
try {
|
||||
const { autistmask } = await storageGet("autistmask");
|
||||
return normalizePersisted(autistmask).networkId === networkId;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = { storedSettingIsOn, storedNetworkIs };
|
||||
module.exports = { storedSettingIsOn };
|
||||
|
||||
@@ -19,8 +19,7 @@
|
||||
// them hid the other one's holders' money (issue #276). Membership, not
|
||||
// equality, is therefore the question — but it is the same question, asked of
|
||||
// a table that can now state the truth. Every address in a set is one the
|
||||
// wallet ships as a real token on Ethereum Mainnet. On mainnet, a contract
|
||||
// outside the set is still a spoof.
|
||||
// wallet ships as a real token; a contract outside the set is still a spoof.
|
||||
//
|
||||
// The symbol is attacker-controlled — it is whatever the ERC-20 contract
|
||||
// returns — so the lookup is done on a normalized form (issue #260): the
|
||||
@@ -28,7 +27,6 @@
|
||||
// since that is what the user acts on.
|
||||
|
||||
const { KNOWN_SYMBOLS } = require("./tokenList");
|
||||
const { NETWORKS } = require("./networks");
|
||||
|
||||
// Ethereum addresses are case-insensitive: EIP-55 mixed case is a checksum
|
||||
// over the address, not part of its identity.
|
||||
@@ -95,24 +93,18 @@ function normalizeSymbol(symbol) {
|
||||
}
|
||||
|
||||
// True when a token bearing `symbol` from contract `contractAddress` is
|
||||
// impersonating a known symbol. `chainId` is the chain id of the token's
|
||||
// network.
|
||||
//
|
||||
// The native asset's labels are known symbols on every network. The bundled
|
||||
// list's symbols are known symbols only on Ethereum Mainnet, because the list
|
||||
// holds mainnet contracts.
|
||||
// impersonating a known symbol.
|
||||
//
|
||||
// An empty contract address is the native asset, which is never a spoof:
|
||||
// this is what keeps the user's real ETH out of the rule, and it holds for
|
||||
// any symbol that becomes null-mapped later, not just for ETH.
|
||||
function isSpoofedSymbol(symbol, contractAddress, chainId) {
|
||||
function isSpoofedSymbol(symbol, contractAddress) {
|
||||
const contract = normalizeAddress(contractAddress);
|
||||
if (!contract) return false;
|
||||
const sym = normalizeSymbol(symbol);
|
||||
if (!KNOWN_SYMBOLS.has(sym)) return false;
|
||||
const legit = KNOWN_SYMBOLS.get(sym);
|
||||
if (legit === null) return true;
|
||||
if (chainId !== NETWORKS.mainnet.chainId) return false;
|
||||
return !legit.has(contract);
|
||||
}
|
||||
|
||||
|
||||
+35
-367
@@ -4,12 +4,12 @@
|
||||
// Addresses are EIP-55 checksummed.
|
||||
//
|
||||
// 511 tokens.
|
||||
//
|
||||
// Below the list, USD_PRICE_FEEDS gives the Chainlink USD price feed of each
|
||||
// token that has one.
|
||||
|
||||
const { debugFetch } = require("./log");
|
||||
const { NETWORKS } = require("./networks");
|
||||
|
||||
const COINDESK_API = "https://data-api.coindesk.com/index/cc/v1/latest/tick";
|
||||
|
||||
const TOKENS = [
|
||||
{
|
||||
address: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
|
||||
@@ -3597,351 +3597,6 @@ const TOKENS = [
|
||||
},
|
||||
];
|
||||
|
||||
// Chainlink price feeds on Ethereum mainnet. Each feed is a contract whose
|
||||
// latestRoundData() returns a USD price and the time the price was written.
|
||||
// The fields of a feed:
|
||||
//
|
||||
// - address: the feed's contract
|
||||
// - heartbeat: the most seconds the feed goes without a new price
|
||||
// - decimals: the number of decimal places in the price
|
||||
//
|
||||
// Each feed's address and heartbeat come from Chainlink's published list of
|
||||
// mainnet feeds. Each feed was checked on mainnet by reading its description()
|
||||
// and decimals().
|
||||
|
||||
// The ETH/USD feed, which prices ether and WETH.
|
||||
const ETH_USD_FEED = {
|
||||
address: "0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419",
|
||||
heartbeat: 3600,
|
||||
decimals: 8,
|
||||
};
|
||||
|
||||
// The USD feed of each token in TOKENS that has one, keyed by the token's
|
||||
// contract address as TOKENS spells it. A token is paired with its feed by its
|
||||
// address alone, so a token that copies a listed token's symbol gets no feed.
|
||||
const USD_PRICE_FEEDS = {
|
||||
// WETH
|
||||
"0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2": ETH_USD_FEED,
|
||||
// USDT
|
||||
"0xdAC17F958D2ee523a2206206994597C13D831ec7": {
|
||||
address: "0x3E7d1eAB13ad0104d2750B8863b489D65364e32D",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// BNB
|
||||
"0xB8c77482e45F1F44dE1745F52C74426C631bDD52": {
|
||||
address: "0x14e613AC84a31f709eadbdF89C6CC390fDc9540A",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// USDC
|
||||
"0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": {
|
||||
address: "0x8fFfFfd4AfB6115b954Bd326cbe7B4BA576818f6",
|
||||
heartbeat: 82800,
|
||||
decimals: 8,
|
||||
},
|
||||
// USDS
|
||||
"0xdC035D45d973E3EC169d2276DDab16f1e407384F": {
|
||||
address: "0xfF30586cD0F29eD462364C7e81375FC0C71219b1",
|
||||
heartbeat: 82800,
|
||||
decimals: 8,
|
||||
},
|
||||
// LINK
|
||||
"0x514910771AF9Ca656af840dff83E8264EcF986CA": {
|
||||
address: "0x2c1d072e956AFFC0D435Cb7AC38EF18d24d9127c",
|
||||
heartbeat: 3600,
|
||||
decimals: 8,
|
||||
},
|
||||
// USDE
|
||||
"0x4c9EDD5852cd905f086C759E8383e09bff1E68B3": {
|
||||
address: "0xa569d910839Ae8865Da8F8e70FfFb0cBA869F961",
|
||||
heartbeat: 82800,
|
||||
decimals: 8,
|
||||
},
|
||||
// USD1
|
||||
"0x8d0D000Ee44948FC98c9B98A4FA4921476f08B0d": {
|
||||
address: "0xF0d9bb015Cd7BfAb877B7156146dc09Bf461370d",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// DAI
|
||||
"0x6B175474E89094C44Da98b954EedeAC495271d0F": {
|
||||
address: "0xAed0c38402a5d19df6E4c03F4E2DceD6e29c1ee9",
|
||||
heartbeat: 3600,
|
||||
decimals: 8,
|
||||
},
|
||||
// PYUSD
|
||||
"0x6c3ea9036406852006290770BEdFcAbA0e23A0e8": {
|
||||
address: "0x8f1dF6D7F2db73eECE86a18b4381F4707b918FB1",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// WLFI
|
||||
"0xdA5e1988097297dCdc1f90D4dFE7909e847CBeF6": {
|
||||
address: "0x14E5FC91Ddb3f97C33013Cc9fA74F54062Ad1Aa1",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// UNI
|
||||
"0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984": {
|
||||
address: "0x553303d460EE0afB37EdFf9bE42922D8FF63220e",
|
||||
heartbeat: 3600,
|
||||
decimals: 8,
|
||||
},
|
||||
// PAXG
|
||||
"0x45804880De22913dAFE09f4980848ECE6EcbAf78": {
|
||||
address: "0x9944D86CEB9160aF5C5feB251FD671923323f8C3",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// AAVE
|
||||
"0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9": {
|
||||
address: "0x547a514d5e3769680Ce22B2361c10Ea13619e8a9",
|
||||
heartbeat: 3600,
|
||||
decimals: 8,
|
||||
},
|
||||
// USDF
|
||||
"0xFa2B947eEc368f42195f24F36d2aF29f7c24CeC2": {
|
||||
address: "0xb177857a1799aA5F7fEb5799Fdf12CbE8fdF78B1",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// USDG
|
||||
"0xe343167631d89B6Ffc58B88d6b7fB0228795491D": {
|
||||
address: "0x14f0737d6b705259e521EA6E9E3506AC78dBd311",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// SKY
|
||||
"0x56072C95FAA701256059aa122697B133aDEd9279": {
|
||||
address: "0xee10fE5E7aa92dd7b136597449c3d5813cFC5F18",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// RLUSD
|
||||
"0x8292Bb45bf1Ee4d140127049757C2E0fF06317eD": {
|
||||
address: "0x26C46B7aD0012cA71F2298ada567dC9Af14E7f2A",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// USDTB
|
||||
"0xC139190F447e929f090Edeb554D95AbB8b18aC1C": {
|
||||
address: "0x66704DAD467A7cA508B3be15865D9B9F3E186c90",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// ARB
|
||||
"0xB50721BCf8d664c30412Cfbc6cf7a15145234ad1": {
|
||||
address: "0x31697852a68433DbCc2Ff612c516d69E3D9bd08F",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// USD0
|
||||
"0x73A15FeD60Bf67631dC6cd7Bc5B6e8da8190aCF5": {
|
||||
address: "0x7e891DEbD8FA0A4Cf6BE58Ddff5a8ca174FebDCB",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// GHO
|
||||
"0x40D16FC0246aD3160Ccc09B8D0D3A2cD28aE6C2f": {
|
||||
address: "0x3f12643D3f6f874d39C2a4c9f2Cd6f2DbAC877FC",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// TUSD
|
||||
"0x0000000000085d4780B73119b644AE5ecd22b376": {
|
||||
address: "0xec746eCF986E2927Abd291a2A1716c940100f8Ba",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// EURC
|
||||
"0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c": {
|
||||
address: "0x04F84020Fdf10d9ee64D1dcC2986EDF2F556DA11",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// FDUSD
|
||||
"0xc5f0f7b66764F6ec8C8Dff7BA683102295E16409": {
|
||||
address: "0xfAA9147190c2C2cc5B8387B4f49016bDB3380572",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// CRV
|
||||
"0xD533a949740bb3306d119CC777fa900bA034cd52": {
|
||||
address: "0xCd627aA160A6fA45Eb793D19Ef54f5062F20f33f",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// GRT
|
||||
"0xc944E90C64B2c07662A292be6244BDf05Cda44a7": {
|
||||
address: "0x86cF33a451dE9dc61a2862FD94FF4ad4Bd65A5d2",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// CRVUSD
|
||||
"0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E": {
|
||||
address: "0xEEf0C605546958c1f899b6fB336C20671f9cD49F",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// FRAX, the Legacy Frax Dollar, priced by Chainlink's FRAX / USD feed
|
||||
"0x853d955aCEf822Db058eb8505911ED77F175b99e": {
|
||||
address: "0xB9E1E3A9feFf48998E45Fa90847ed4D467E8BcfD",
|
||||
heartbeat: 3600,
|
||||
decimals: 8,
|
||||
},
|
||||
// ENS
|
||||
"0xC18360217D8F7Ab5e7c516566761Ea12Ce7F9D72": {
|
||||
address: "0x5C00128d4d1c2F4f652C267d7bcdD7aC99C16E16",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// SAND
|
||||
"0x3845badAde8e6dFF049820680d1F14bD3903a5d0": {
|
||||
address: "0x35E3f7E558C04cE7eEE1629258EcbbA03B36Ec56",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// AUSD
|
||||
"0x00000000eFE302BEAA2b3e6e1b18d08D69a9012a": {
|
||||
address: "0xB00341502DfEA6Ced8A5786b4059d29dA5E4D1FD",
|
||||
heartbeat: 86400,
|
||||
decimals: 18,
|
||||
},
|
||||
// COMP
|
||||
"0xc00e94Cb662C3520282E6f5717214004A7f26888": {
|
||||
address: "0xdbd020CAeF83eFd542f4De03e3cF0C28A4428bd5",
|
||||
heartbeat: 3600,
|
||||
decimals: 8,
|
||||
},
|
||||
// XCN
|
||||
"0xA2cd3D43c775978A96BdBf12d733D5A1ED94fb18": {
|
||||
address: "0xeb988B77b94C186053282BfcD8B7ED55142D3cAB",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// CVX
|
||||
"0x4e3FBD56CD56c3e72c1403e103b45Db9da5B9D2B": {
|
||||
address: "0xd962fC30A72A84cE50161031391756Bf2876Af5D",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// IMX
|
||||
"0xF57e7e7C23978C3cAEC3C3548E3D615c346e79fF": {
|
||||
address: "0xBAEbEFc1D023c0feCcc047Bff42E75F15Ff213E6",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// 1INCH
|
||||
"0x111111111117dC0aa78b770fA6A738034120C302": {
|
||||
address: "0xc929ad75B72593967DE83E7F7Cda0493458261D9",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// SNX
|
||||
"0xC011a73ee8576Fb46F5E1c5751cA3B9Fe0af2a6F": {
|
||||
address: "0xDC3EA94CD0AC27d9A86C180091e7f78C683d3699",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// DOLA
|
||||
"0x865377367054516e17014CcdED1e7d814EDC9ce4": {
|
||||
address: "0xE33592594f72Cc7ec8a05788be8E8455746C3a32",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// FRXUSD
|
||||
"0xCAcd6fd266aF91b8AeD52aCCc382b4e165586E29": {
|
||||
address: "0x9B4a96210bc8D9D55b1908B465D8B0de68B7fF83",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// YFI
|
||||
"0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e": {
|
||||
address: "0xA027702dbb89fbd58938e4324ac03B58d812b0E1",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// RSR
|
||||
"0x320623b8E4fF03373931769A31Fc52A4E78B5d70": {
|
||||
address: "0x759bBC1be8F90eE6457C44abc7d443842a976d02",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// ZRX
|
||||
"0xE41d2489571d322189246DaFA5ebDe1F4699F498": {
|
||||
address: "0x2885d15b8Af22648b98B122b22FDF4D2a56c6023",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// FRAX, formerly FXS, priced by Chainlink's FXS / USD feed
|
||||
"0x3432B6A60D23Ca0dFCa7761B7ab56459D9C964D0": {
|
||||
address: "0x6Ebc52C8C1089be9eB3945C4350B68B8E4C2233f",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// SXT
|
||||
"0xE6Bfd33F52d82Ccb5b37E16D3dD81f9FFDAbB195": {
|
||||
address: "0x2D27d9e1b74936D8E83c4BA118F09A4c4a897f62",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// SUSHI
|
||||
"0x6B3595068778DD592e39A122f4f5a5cF09C90fE2": {
|
||||
address: "0xCc70F09A6CC17553b2E31954cD36E4A2d89501f7",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// RPL
|
||||
"0xD33526068D116cE69F19A9ee46F0bd304F21A51f": {
|
||||
address: "0x4E155eD98aFE9034b7A5962f6C84c86d869daA9d",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// USDP
|
||||
"0x8E870D67F660D95d5be530380D0eC0bd388289E1": {
|
||||
address: "0x09023c0DA49Aaf8fc3fA3ADF34C6A7016D38D5e3",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// SPELL
|
||||
"0x090185f2135308BaD17527004364eBcC2D37e5F6": {
|
||||
address: "0x8c110B94C5f1d347fAcF5E1E938AB2db60E3c9a8",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// LUSD
|
||||
"0x5f98805A4E8be255a32880FDeC7F6728C6568bA0": {
|
||||
address: "0x3D7aE7E594f2f2091Ad8798313450130d0Aba3a0",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// STG
|
||||
"0xAf5191B0De278C7286d6C7CC6ab6BB8A73bA2Cd6": {
|
||||
address: "0x7A9f34a0Aa917D438e9b6E630067062B7F8f6f3d",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// KNC
|
||||
"0xdeFA4e8a7bcBA345F687a2f1456F5Edd9CE97202": {
|
||||
address: "0xf8fF43E991A81e6eC886a3D281A2C6cC19aE70Fc",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
// MUSD (the other MUSD in TOKENS has no feed)
|
||||
"0xacA92E438df0B2401fF60dA7E4337B687a2435DA": {
|
||||
address: "0xc90E3460424fb8ea79775089E9053113FEE34Ed0",
|
||||
heartbeat: 86400,
|
||||
decimals: 8,
|
||||
},
|
||||
};
|
||||
|
||||
// Build a map of token address (lowercased) -> its USD price feed.
|
||||
const PRICE_FEED_BY_ADDRESS = new Map();
|
||||
for (const [address, feed] of Object.entries(USD_PRICE_FEEDS)) {
|
||||
PRICE_FEED_BY_ADDRESS.set(address.toLowerCase(), feed);
|
||||
}
|
||||
|
||||
// Return the top N tokens from the list.
|
||||
function getTopTokens(n) {
|
||||
return TOKENS.slice(0, n);
|
||||
@@ -3953,15 +3608,6 @@ for (const t of TOKENS) {
|
||||
TOKEN_BY_ADDRESS.set(t.address.toLowerCase(), t);
|
||||
}
|
||||
|
||||
// The bundled list's entry for the contract at `address` on the network with
|
||||
// chain id `chainId`, or null. The list holds Ethereum Mainnet contracts only.
|
||||
// A contract at the same address on another network is another token, so any
|
||||
// other chain id gets null.
|
||||
function bundledToken(address, chainId) {
|
||||
if (chainId !== NETWORKS.mainnet.chainId) return null;
|
||||
return TOKEN_BY_ADDRESS.get((address || "").toLowerCase()) || null;
|
||||
}
|
||||
|
||||
// Build a map of symbol (uppercased) -> the set of contract addresses
|
||||
// (lowercased) that legitimately bear it. Used for spoofed-symbol detection.
|
||||
// "ETH" maps to null: the native asset has no contract, so no contract may
|
||||
@@ -3978,8 +3624,7 @@ function bundledToken(address, chainId) {
|
||||
// hides from the balance list, the history and the send selector at its own
|
||||
// address, so the user cannot spend it (issue #276). Naming every address
|
||||
// that bears the symbol is the only shape that says what is true; it does not
|
||||
// loosen the rule. On Ethereum Mainnet, a contract outside the set is still a
|
||||
// spoof.
|
||||
// loosen the rule, because a contract outside the set is still a spoof.
|
||||
const KNOWN_SYMBOLS = new Map();
|
||||
KNOWN_SYMBOLS.set("ETH", null);
|
||||
for (const network of Object.values(NETWORKS)) {
|
||||
@@ -3998,15 +3643,41 @@ for (const t of TOKENS) {
|
||||
}
|
||||
}
|
||||
|
||||
// Resolve a token symbol from multiple sources, never returning "?". The token
|
||||
// is a contract on the network with chain id `chainId`.
|
||||
function resolveSymbol(tokenAddress, tokenBalances, trackedTokens, chainId) {
|
||||
// Fetch USD prices for the top N tokens from CoinDesk.
|
||||
// Also always includes ETH. Returns { ETH: 1234.56, LINK: 8.60, ... }.
|
||||
// n must be <= 30 (API and sanity limit).
|
||||
async function getTopTokenPrices(n) {
|
||||
if (n > 30) {
|
||||
throw new Error("getTopTokenPrices: n must be <= 30, got " + n);
|
||||
}
|
||||
const symbols = ["ETH", ...TOKENS.slice(0, n).map((t) => t.symbol)];
|
||||
const unique = [...new Set(symbols)];
|
||||
const instruments = unique.map((s) => s + "-USD").join(",");
|
||||
const url =
|
||||
COINDESK_API +
|
||||
"?market=cadli&instruments=" +
|
||||
instruments +
|
||||
"&apply_mapping=true";
|
||||
const resp = await debugFetch(url);
|
||||
const json = await resp.json();
|
||||
const prices = {};
|
||||
for (const [instrument, data] of Object.entries(json.Data || {})) {
|
||||
const symbol = instrument.split("-")[0];
|
||||
if (data.VALUE !== undefined) {
|
||||
prices[symbol] = data.VALUE;
|
||||
}
|
||||
}
|
||||
return prices;
|
||||
}
|
||||
|
||||
// Resolve a token symbol from multiple sources, never returning "?".
|
||||
function resolveSymbol(tokenAddress, tokenBalances, trackedTokens) {
|
||||
const lower = (tokenAddress || "").toLowerCase();
|
||||
const tb = (tokenBalances || []).find(
|
||||
(t) => t.address.toLowerCase() === lower,
|
||||
);
|
||||
if (tb && tb.symbol) return tb.symbol;
|
||||
const known = bundledToken(lower, chainId);
|
||||
const known = TOKEN_BY_ADDRESS.get(lower);
|
||||
if (known && known.symbol) return known.symbol;
|
||||
const tracked = (trackedTokens || []).find(
|
||||
(t) => t.address.toLowerCase() === lower,
|
||||
@@ -4019,10 +3690,7 @@ module.exports = {
|
||||
TOKENS,
|
||||
TOKEN_BY_ADDRESS,
|
||||
KNOWN_SYMBOLS,
|
||||
ETH_USD_FEED,
|
||||
USD_PRICE_FEEDS,
|
||||
PRICE_FEED_BY_ADDRESS,
|
||||
getTopTokens,
|
||||
bundledToken,
|
||||
getTopTokenPrices,
|
||||
resolveSymbol,
|
||||
};
|
||||
|
||||
@@ -8,7 +8,7 @@
|
||||
|
||||
const { formatEther, formatUnits } = require("ethers");
|
||||
const { log, debugFetch } = require("./log");
|
||||
const { bundledToken } = require("./tokenList");
|
||||
const { TOKEN_BY_ADDRESS } = require("./tokenList");
|
||||
const { parseHoldersCount, isLowHolderCount } = require("./holders");
|
||||
const { isSpoofedSymbol } = require("./symbolSpoof");
|
||||
const { nativeCurrencyByChainId } = require("./networks");
|
||||
@@ -47,7 +47,7 @@ function parseTx(tx, addrLower, chainId) {
|
||||
let direction = normalizeAddress(from) === addrLower ? "sent" : "received";
|
||||
let directionLabel = direction === "sent" ? "Sent" : "Received";
|
||||
if (toIsContract && method && method !== "transfer") {
|
||||
const token = bundledToken(to, chainId);
|
||||
const token = TOKEN_BY_ADDRESS.get(normalizeAddress(to));
|
||||
if (token) {
|
||||
symbol = token.symbol;
|
||||
}
|
||||
@@ -317,10 +317,7 @@ function filterTransactions(txs, filters = {}) {
|
||||
const contract = normalizeAddress(tx.contractAddress);
|
||||
|
||||
// Filter spoofed known symbols and record the fraud contract
|
||||
if (
|
||||
hideSpoofed &&
|
||||
isSpoofedSymbol(tx.symbol, tx.contractAddress, tx.chainId)
|
||||
) {
|
||||
if (hideSpoofed && isSpoofedSymbol(tx.symbol, tx.contractAddress)) {
|
||||
if (contract && !fraudSet.has(contract)) {
|
||||
fraudSet.add(contract);
|
||||
newFraud.push(contract);
|
||||
|
||||
+148
-290
@@ -452,8 +452,8 @@ const ADDRESS_THIS = "0x0000000000000000000000000000000000000002";
|
||||
// `decimals` is null when nothing knows this token's scale. It is not
|
||||
// defaulted to 18: the swap lines land on the same approval screen as the
|
||||
// ERC-20 line, and a scale guessed there is what showed a 1,000 USDT swap as
|
||||
// 0.000000000001. `sources` is as for resolveTokenDecimals(), which reads the
|
||||
// bundled list on Ethereum Mainnet, then the tracked tokens and the wallets.
|
||||
// 0.000000000001. `sources` is { trackedTokens, wallets }, shaped as they are
|
||||
// on `state`; resolveTokenDecimals() reads the bundled list, then those.
|
||||
//
|
||||
// A null `address` means UNDETERMINED — the calldata named no currency for
|
||||
// that side — and is refused rather than named. It is not native ETH: Uniswap
|
||||
@@ -479,17 +479,6 @@ function tokenInfo(address, sources) {
|
||||
};
|
||||
}
|
||||
|
||||
// The token of a Permit2 allowance or of a PERMIT2_TRANSFER_FROM, in the
|
||||
// shape tokenInfo() gives. Permit2 has no allowance of ETH and moves no ETH.
|
||||
// The zero address there reads as a token nothing knows: its amount in base
|
||||
// units, and the zero address as its token.
|
||||
function permit2TokenInfo(address, sources) {
|
||||
if (address === "0x0000000000000000000000000000000000000000") {
|
||||
return { symbol: null, decimals: null, address };
|
||||
}
|
||||
return tokenInfo(address, sources);
|
||||
}
|
||||
|
||||
// A swap amount line. With a scale it is the token quantity; with none it is
|
||||
// the base-unit integer with the unknown scale stated, the same refusal the
|
||||
// ERC-20 amount line makes, so the screen has one way of saying it. `display`
|
||||
@@ -508,18 +497,16 @@ function amountText(raw, info) {
|
||||
|
||||
// The line giving a moved token, or the token of a permit, under `label`, in
|
||||
// the shape of the Token In line, so the screens show it as they show that
|
||||
// one. `info` is what tokenInfo() or permit2TokenInfo() gives for the token.
|
||||
// ETH has no address.
|
||||
function tokenMovedLine(label, info) {
|
||||
// one. ETH has no address.
|
||||
function tokenMovedLine(label, token, sources) {
|
||||
const info = tokenInfo(token, sources);
|
||||
if (!present(info.address)) {
|
||||
return { label, value: info.symbol };
|
||||
}
|
||||
return {
|
||||
label,
|
||||
value: info.symbol
|
||||
? info.symbol + " (" + info.address + ")"
|
||||
: info.address,
|
||||
address: info.address,
|
||||
value: info.symbol ? info.symbol + " (" + token + ")" : token,
|
||||
address: token,
|
||||
isToken: true,
|
||||
};
|
||||
}
|
||||
@@ -988,9 +975,6 @@ function totalAmount(amounts) {
|
||||
// pays it of Token In as the step's amount in place of the rules' Amount, or
|
||||
// no amount when this decoder cannot tell what that is.
|
||||
//
|
||||
// `spent` lists the currency that each swap action spends, for each swap
|
||||
// action that this decoder could read.
|
||||
//
|
||||
// `takes` is every TAKE, TAKE_ALL and TAKE_PORTION, as the currency it takes
|
||||
// and its recipient as written, MSG_SENDER for a TAKE_ALL. TAKE_PORTION takes
|
||||
// a share of the currency, so it does not name the output side as TAKE does.
|
||||
@@ -1166,8 +1150,6 @@ function decodeV4Swap(input) {
|
||||
}
|
||||
}
|
||||
|
||||
const spent = swaps.map((s) => s.tokenIn);
|
||||
|
||||
// Rule 3.
|
||||
if (swapUndecoded) {
|
||||
return {
|
||||
@@ -1175,7 +1157,6 @@ function decodeV4Swap(input) {
|
||||
tokenOut: takeToken,
|
||||
amountIn: null,
|
||||
amountOutMin: null,
|
||||
spent,
|
||||
takes,
|
||||
settledFromRouter,
|
||||
paidByUser,
|
||||
@@ -1186,6 +1167,7 @@ function decodeV4Swap(input) {
|
||||
};
|
||||
}
|
||||
|
||||
const spent = swaps.map((s) => s.tokenIn);
|
||||
const bought = swaps.map((s) => s.tokenOut);
|
||||
|
||||
// Rules 1 and 2 for Token In.
|
||||
@@ -1221,7 +1203,6 @@ function decodeV4Swap(input) {
|
||||
tokenOut,
|
||||
amountIn,
|
||||
amountOutMin,
|
||||
spent,
|
||||
takes,
|
||||
settledFromRouter,
|
||||
paidByUser,
|
||||
@@ -1246,9 +1227,6 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
const release = routerRelease(toAddress, chainId);
|
||||
if (release === null) return null;
|
||||
const { commandTypeMask, commands, allowRevert } = release;
|
||||
// The swap's tokens are contracts on the network with `chainId`, so they
|
||||
// are named and scaled for that network.
|
||||
const tokenSources = { ...sources, chainId };
|
||||
try {
|
||||
const parsed = ROUTER_IFACE.parseTransaction({ data });
|
||||
if (!parsed) return null;
|
||||
@@ -1262,10 +1240,9 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
let inputEstablished = false;
|
||||
// Whether the user pays the step that set the input side: a V2 or V3
|
||||
// swap step with `payerIsUser` true, a V4 step the user pays some of
|
||||
// its input currency (see paidByUser in the loop), or a WRAP_ETH,
|
||||
// whose ETH comes from the transaction's value. A step that pays an
|
||||
// ERC-20 token from the router takes none of that token from the
|
||||
// sender.
|
||||
// its input currency (see decodeV4Swap()), or a WRAP_ETH, whose ETH
|
||||
// comes from the transaction's value. A step paid from the router
|
||||
// takes nothing from the sender.
|
||||
let inputPaidByUser = false;
|
||||
// The recipient of a WRAP_ETH that set the input side, as written,
|
||||
// when it is not the router; otherwise null. That WRAP_ETH pays its
|
||||
@@ -1320,9 +1297,8 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
const commandNames = [];
|
||||
|
||||
// THE INVARIANT: an amount and the token it is counted in always come
|
||||
// from the same hop, or from hops that all spend that token or all buy
|
||||
// it. A figure is never rendered against a token that did not supply
|
||||
// it.
|
||||
// from the same hop, or from hops that all spend that token. A figure
|
||||
// is never rendered against a token that did not supply it.
|
||||
//
|
||||
// Both sides are therefore set as a PAIR — never field by field, and
|
||||
// never on truthiness. An address is never falsy once set but an
|
||||
@@ -1366,17 +1342,13 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
// What the steps take from the sender beyond the amount of the step
|
||||
// that sets the input side, as { token, amount }, in step order.
|
||||
// After the loop each joins the Amount line or gets lines of its own
|
||||
// (see permitStands). A take with `atMost` set may take less than
|
||||
// `amount`: it never joins the Amount line, and its line reads
|
||||
// "Up to" and the amount.
|
||||
// (see permitStands).
|
||||
const userPaid = [];
|
||||
// A swap step the user pays for (`payerIsUser` true) takes `amount`
|
||||
// of `token` from the sender, or at most that when `atMost` is set. A
|
||||
// V2 exact-in of ALREADY_PAID takes nothing.
|
||||
const addUserPaid = (token, amount, atMost = false) => {
|
||||
if (amount !== ALREADY_PAID) {
|
||||
userPaid.push({ token, amount, atMost });
|
||||
}
|
||||
// of `token` from the sender. A V2 exact-in of ALREADY_PAID takes
|
||||
// nothing.
|
||||
const addUserPaid = (token, amount) => {
|
||||
if (amount !== ALREADY_PAID) userPaid.push({ token, amount });
|
||||
};
|
||||
// A step may take from the sender what this decoder did not read: a
|
||||
// V4 step whose input or one of whose SETTLEs or SETTLE_ALLs it
|
||||
@@ -1431,31 +1403,33 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
// token, an UNWRAP_WETH of WETH, a WRAP_ETH of CONTRACT_BALANCE of
|
||||
// ETH, a TRANSFER, PAY_PORTION, PAY_PORTION_FULL_PRECISION or
|
||||
// ACROSS_V4_DEPOSIT_V3 of all of it, or a swap step or V4 SETTLE paid
|
||||
// from the router (see spendFromRouter()). The value is the amount the
|
||||
// router holds, in base units, when a WRAP_ETH stated it, otherwise
|
||||
// null.
|
||||
// from the router (see spendFromRouter()). A V4 SETTLE of ETH paid by
|
||||
// the user spends the router's ETH too (see the V4_SWAP branch). The
|
||||
// value is the amount the router holds, in base units, when a
|
||||
// WRAP_ETH stated it, otherwise null. A step that spends an unstated
|
||||
// amount of the token from the router makes the value null. An
|
||||
// UNWRAP_WETH into the router turns that amount of WETH into the same
|
||||
// amount of ETH.
|
||||
const heldByRouter = new Map();
|
||||
const isRouter = (recipient) => {
|
||||
const r = recipient.toLowerCase();
|
||||
return r === ADDRESS_THIS || r === toAddress.toLowerCase();
|
||||
};
|
||||
const isSender = (recipient) => {
|
||||
const r = recipient.toLowerCase();
|
||||
return r === MSG_SENDER || r === sender;
|
||||
};
|
||||
// A swap step or V4 SETTLE pays `amount` of `token` from the router's
|
||||
// own balance. CONTRACT_BALANCE pays all of it. Any other quantity
|
||||
// counts against the amount a WRAP_ETH stated, and the steps pay all
|
||||
// of it once their amounts reach that one: a swap paid in ETH wraps
|
||||
// what its swap steps then spend. An amount that is not a quantity,
|
||||
// such as the null decodeV4Swap() gives a SETTLE whose payment it
|
||||
// cannot tell, or one of a token whose amount is not known, pays out
|
||||
// nothing this decoder can see.
|
||||
// counts against a known amount the router holds, and the steps pay
|
||||
// all of it once their amounts reach that one: a swap paid in ETH wraps
|
||||
// what its swap steps then spend. A null amount is one the calldata
|
||||
// does not state, as for a V2 or V3 exact-out or a SETTLE whose
|
||||
// payment decodeV4Swap() cannot tell. A null amount makes the
|
||||
// router's amount of the token unknown. ALREADY_PAID spends nothing.
|
||||
const spendFromRouter = (token, amount) => {
|
||||
const t = token.toLowerCase();
|
||||
const held = heldByRouter.get(t);
|
||||
if (amount === CONTRACT_BALANCE) {
|
||||
heldByRouter.delete(t);
|
||||
} else if (amount === null) {
|
||||
if (heldByRouter.has(t)) heldByRouter.set(t, null);
|
||||
} else if (typeof held === "bigint" && typeof amount === "bigint") {
|
||||
if (amount >= held) {
|
||||
heldByRouter.delete(t);
|
||||
@@ -1475,73 +1449,17 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
// A step pays `recipient`. `output` is the token a swap step or a V4
|
||||
// TAKE or TAKE_PORTION pays; other steps pass none.
|
||||
const addPayee = (recipient, output) => {
|
||||
const r = recipient.toLowerCase();
|
||||
if (isRouter(recipient)) {
|
||||
if (present(output)) {
|
||||
heldByRouter.set(output.toLowerCase(), null);
|
||||
}
|
||||
} else if (isSender(recipient)) {
|
||||
} else if (r === MSG_SENDER || r === sender) {
|
||||
paidToSender = true;
|
||||
} else {
|
||||
addPaidElsewhere(recipient);
|
||||
}
|
||||
};
|
||||
// Each swap step that paid the sender some of the token it bought,
|
||||
// as { step, token, amount, onlyToSender }:
|
||||
// - `step` is the step's index;
|
||||
// - `token` is that token;
|
||||
// - `amount` is the step's stated minimum;
|
||||
// - `onlyToSender` is whether the step paid all of that token to the
|
||||
// sender.
|
||||
// A later step that spends that token takes the step off this list
|
||||
// (see dropFromSum()).
|
||||
let swapsPayingSender = [];
|
||||
// The step being read spends `token`, so it may spend what an earlier
|
||||
// swap step paid the sender. Each step on swapsPayingSender that
|
||||
// bought `token` leaves the list. A step spends a token as follows:
|
||||
// - a V2 or V3 swap step spends its input token;
|
||||
// - a V4 step spends each token that one of its swap actions spends,
|
||||
// and each token that one of its SETTLEs or SETTLE_ALLs pays;
|
||||
// - a PERMIT2_TRANSFER_FROM spends the token it moves.
|
||||
const dropFromSum = (token) => {
|
||||
swapsPayingSender = swapsPayingSender.filter(
|
||||
(s) => !sameAddress(s.token, token),
|
||||
);
|
||||
};
|
||||
// The minimum the output side shows for the swap step at `step`. The
|
||||
// step buys `token` with the stated minimum `amount`, and pays
|
||||
// `token` to `recipients`. The minimum is the step's own, unless this
|
||||
// step and an earlier one on swapsPayingSender both pay `token` to
|
||||
// the sender, as a route split across steps does. The minimum is then
|
||||
// the total of all such steps' minimums. There is none when this
|
||||
// decoder reads no minimum from one of them, or when one of them pays
|
||||
// some of `token` elsewhere. There is also none when this decoder did
|
||||
// not read one of them, or a step between them, in full (see
|
||||
// stepsUnread).
|
||||
const swapMinimum = (step, token, amount, recipients) => {
|
||||
const toSender = recipients.filter(
|
||||
(r) => present(r) && isSender(r),
|
||||
);
|
||||
if (toSender.length === 0) return amount;
|
||||
swapsPayingSender.push({
|
||||
step,
|
||||
token,
|
||||
amount,
|
||||
onlyToSender: toSender.length === recipients.length,
|
||||
});
|
||||
const split = swapsPayingSender.filter((s) =>
|
||||
sameAddress(s.token, token),
|
||||
);
|
||||
if (split.length < 2) return amount;
|
||||
if (
|
||||
split.some(
|
||||
(s) => !s.onlyToSender || typeof s.amount !== "bigint",
|
||||
) ||
|
||||
stepsUnread.some((unread) => unread >= split[0].step)
|
||||
) {
|
||||
return null;
|
||||
}
|
||||
return split.reduce((sum, s) => sum + s.amount, 0n);
|
||||
};
|
||||
// A step that pays `token` to `recipient` is a hop, not a payout,
|
||||
// when the very next step is a V2 exact-in whose input is already
|
||||
// paid, whose path starts at `token`, and whose pair (see v2PairFor())
|
||||
@@ -1683,7 +1601,6 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
: null,
|
||||
});
|
||||
}
|
||||
if (p) dropFromSum(p.token);
|
||||
} else if (command === "BALANCE_CHECK_ERC20") {
|
||||
const b = decodeBalanceCheck(inputs[i]);
|
||||
if (!b) {
|
||||
@@ -1706,13 +1623,13 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
} else {
|
||||
// The router passes this check whenever the owner
|
||||
// holds at least minBalance, so a zero one guarantees
|
||||
// nothing. A check the router lets fail guarantees
|
||||
// nothing either, so it is read as a zero one. A zero
|
||||
// check sets neither Token Out nor the minimum. Any
|
||||
// nothing and does not replace a minimum an earlier
|
||||
// step stated. A check the router lets fail guarantees
|
||||
// nothing either, so it is read as a zero one. Any
|
||||
// other minBalance sets the output side as a swap
|
||||
// does. The check pays nobody.
|
||||
// does. It pays nobody.
|
||||
const minBalance = allowedToFail ? 0n : b.minBalance;
|
||||
if (minBalance !== 0n) {
|
||||
if (!(minBalance === 0n && present(minOutput))) {
|
||||
setOutput(i, b.token, minBalance, []);
|
||||
}
|
||||
keepsRouterWeth = true;
|
||||
@@ -1726,18 +1643,10 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
} else if (s.payerIsUser) {
|
||||
addUserPaid(s.tokenIn, s.amountIn);
|
||||
}
|
||||
dropFromSum(s.tokenIn);
|
||||
// Always update output: in multi-step swaps (V3 → V4),
|
||||
// the last swap step determines the final output
|
||||
// token. swapMinimum() gives the minimum.
|
||||
setOutput(
|
||||
i,
|
||||
s.tokenOut,
|
||||
swapMinimum(i, s.tokenOut, s.amountOutMin, [
|
||||
s.recipient,
|
||||
]),
|
||||
[s.recipient],
|
||||
);
|
||||
// the last swap step determines the final output token
|
||||
// and minimum received amount.
|
||||
setOutput(i, s.tokenOut, s.amountOutMin, [s.recipient]);
|
||||
if (!s.payerIsUser) {
|
||||
spendFromRouter(s.tokenIn, s.amountIn);
|
||||
}
|
||||
@@ -1758,15 +1667,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
} else if (s.payerIsUser) {
|
||||
addUserPaid(s.tokenIn, s.amountIn);
|
||||
}
|
||||
dropFromSum(s.tokenIn);
|
||||
setOutput(
|
||||
i,
|
||||
s.tokenOut,
|
||||
swapMinimum(i, s.tokenOut, s.amountOutMin, [
|
||||
s.recipient,
|
||||
]),
|
||||
[s.recipient],
|
||||
);
|
||||
setOutput(i, s.tokenOut, s.amountOutMin, [s.recipient]);
|
||||
if (!s.payerIsUser) {
|
||||
spendFromRouter(s.tokenIn, s.amountIn);
|
||||
}
|
||||
@@ -1784,8 +1685,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
) {
|
||||
// Buys exactly amountOut and spends at most amountInMax.
|
||||
// Paid from the router, it spends an amount the calldata
|
||||
// does not state, so it spends nothing spendFromRouter()
|
||||
// could count.
|
||||
// does not state (see spendFromRouter()).
|
||||
hasV2OrV3ExactOut = true;
|
||||
const s =
|
||||
command === "V2_SWAP_EXACT_OUT"
|
||||
@@ -1798,15 +1698,10 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
} else if (s.payerIsUser) {
|
||||
addUserPaid(s.tokenIn, s.amountInMax);
|
||||
}
|
||||
dropFromSum(s.tokenIn);
|
||||
setOutput(
|
||||
i,
|
||||
s.tokenOut,
|
||||
swapMinimum(i, s.tokenOut, s.amountOut, [
|
||||
s.recipient,
|
||||
]),
|
||||
[s.recipient],
|
||||
);
|
||||
setOutput(i, s.tokenOut, s.amountOut, [s.recipient]);
|
||||
if (!s.payerIsUser) {
|
||||
spendFromRouter(s.tokenIn, null);
|
||||
}
|
||||
if (!isHop(i, s.tokenOut, s.recipient)) {
|
||||
addPayee(s.recipient, s.tokenOut);
|
||||
}
|
||||
@@ -1935,57 +1830,54 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
} else if (command === "V4_SWAP") {
|
||||
const v4 = decodeV4Swap(inputs[i]);
|
||||
const inputSetBefore = inputEstablished;
|
||||
// V4Router pays a SETTLE of ETH from the router's own
|
||||
// ETH, whichever payer the SETTLE names. The router holds
|
||||
// the transaction's value, and any ETH an earlier step
|
||||
// left it (see heldByRouter). So the user also pays a
|
||||
// SETTLE of ETH that names the router as payer. The user
|
||||
// pays all of its amount when the router holds no other
|
||||
// ETH, and up to its amount otherwise. CONTRACT_BALANCE
|
||||
// pays all the router holds, an amount the calldata does
|
||||
// not state.
|
||||
const routerHeldEth = heldByRouter.has(
|
||||
"0x0000000000000000000000000000000000000000",
|
||||
);
|
||||
const ethFromRouter = (v4?.settledFromRouter ?? [])
|
||||
.filter(
|
||||
(s) =>
|
||||
s.currency ===
|
||||
"0x0000000000000000000000000000000000000000",
|
||||
)
|
||||
.map((s) => ({
|
||||
currency: s.currency,
|
||||
amount:
|
||||
s.amount === CONTRACT_BALANCE ? null : s.amount,
|
||||
}));
|
||||
// What the user pays the step: what decodeV4Swap() says,
|
||||
// and the ETH of each SETTLE from the router of a known
|
||||
// amount when the router holds no other ETH.
|
||||
const paidByUser = v4
|
||||
? v4.paidByUser.concat(
|
||||
routerHeldEth
|
||||
? []
|
||||
: ethFromRouter.filter((s) =>
|
||||
present(s.amount),
|
||||
),
|
||||
)
|
||||
: [];
|
||||
// What the user pays the step, as decodeV4Swap() gives
|
||||
// it, less the ETH the router already holds (below).
|
||||
// Empty when the step cannot be read.
|
||||
const paidByUser = [];
|
||||
if (v4) {
|
||||
// Each SETTLE paid from the router spends the amount
|
||||
// decodeV4Swap() says it pays.
|
||||
for (const s of v4.settledFromRouter) {
|
||||
spendFromRouter(s.currency, s.amount);
|
||||
}
|
||||
// V4Router pays ETH from the router's own ETH,
|
||||
// whoever a SETTLE names as payer. So ETH the router
|
||||
// holds from an earlier step pays first for the ETH
|
||||
// the user would pay the step. The user pays only the
|
||||
// rest. This decoder knows the rest only when it knows
|
||||
// how much ETH the router holds and how much the user
|
||||
// would pay. Otherwise the rest is unknown.
|
||||
for (const p of v4.paidByUser) {
|
||||
if (
|
||||
p.currency !==
|
||||
"0x0000000000000000000000000000000000000000" ||
|
||||
!heldByRouter.has(p.currency)
|
||||
) {
|
||||
paidByUser.push(p);
|
||||
continue;
|
||||
}
|
||||
const held = heldByRouter.get(p.currency);
|
||||
if (
|
||||
typeof held !== "bigint" ||
|
||||
typeof p.amount !== "bigint"
|
||||
) {
|
||||
paidByUser.push({
|
||||
currency: p.currency,
|
||||
amount: null,
|
||||
});
|
||||
} else if (p.amount > held) {
|
||||
paidByUser.push({
|
||||
currency: p.currency,
|
||||
amount: p.amount - held,
|
||||
});
|
||||
}
|
||||
spendFromRouter(p.currency, p.amount);
|
||||
}
|
||||
for (const t of v4.takes) {
|
||||
if (!isHop(i, t.currency, t.recipient)) {
|
||||
addPayee(t.recipient, t.currency);
|
||||
}
|
||||
}
|
||||
for (const token of v4.spent) dropFromSum(token);
|
||||
for (const s of v4.paidByUser) dropFromSum(s.currency);
|
||||
for (const s of v4.settledFromRouter) {
|
||||
dropFromSum(s.currency);
|
||||
}
|
||||
}
|
||||
if (!v4 || v4.recipientUnread) {
|
||||
payeeUnread = true;
|
||||
@@ -2005,9 +1897,9 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
commandNames[i] += " (could not be decoded)";
|
||||
}
|
||||
// The step's amount, if it sets the input side: what the
|
||||
// user pays it of its input currency, or, when the user
|
||||
// pays none of it, what its swap actions spend of it,
|
||||
// whoever pays that.
|
||||
// user pays it of its input currency (see paidByUser),
|
||||
// or, when the user pays none of it, what its swap
|
||||
// actions spend of it, whoever pays that.
|
||||
const paidIn = paidByUser.find(
|
||||
(p) => p.currency === v4.tokenIn,
|
||||
);
|
||||
@@ -2034,12 +1926,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
setInput(v4.tokenIn, amountIn);
|
||||
}
|
||||
outputToken = v4.tokenOut;
|
||||
minOutput = swapMinimum(
|
||||
i,
|
||||
v4.tokenOut,
|
||||
v4.amountOutMin,
|
||||
takeRecipients,
|
||||
);
|
||||
minOutput = v4.amountOutMin;
|
||||
outputEstablished = true;
|
||||
outputUnwrapped = false;
|
||||
unwrapIntoRouterStep = null;
|
||||
@@ -2067,34 +1954,9 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
// router still runs it.
|
||||
const setInputHere = inputEstablished && !inputSetBefore;
|
||||
if (setInputHere) inputPaidByUser = paidIn !== undefined;
|
||||
// ETH an earlier step left in the router may pay part of
|
||||
// the ETH that the user pays this step. The sender then
|
||||
// pays at most that amount.
|
||||
for (const p of paidByUser) {
|
||||
if (setInputHere && p === paidIn) continue;
|
||||
addUserPaid(
|
||||
p.currency,
|
||||
p.amount,
|
||||
routerHeldEth &&
|
||||
p.currency ===
|
||||
"0x0000000000000000000000000000000000000000",
|
||||
);
|
||||
}
|
||||
// A SETTLE of ETH from the router that `paidByUser` leaves
|
||||
// out is a take of its own, even on the step that sets
|
||||
// the input side. Either this decoder does not know its
|
||||
// amount, or ETH an earlier step left in the router may
|
||||
// pay part of that amount (see userPaid).
|
||||
for (const p of ethFromRouter) {
|
||||
if (!present(p.amount)) {
|
||||
addUserPaid(p.currency, null);
|
||||
} else if (routerHeldEth) {
|
||||
userPaid.push({
|
||||
token: p.currency,
|
||||
amount: p.amount,
|
||||
atMost: true,
|
||||
});
|
||||
}
|
||||
addUserPaid(p.currency, p.amount);
|
||||
}
|
||||
if (!v4 || v4.settleUnread) {
|
||||
spentUnread();
|
||||
@@ -2142,15 +2004,23 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
addPayee(u.recipient);
|
||||
// It pays out all the router's WETH, as ETH. Into the
|
||||
// router, the router then holds as ETH the WETH a
|
||||
// step paid it.
|
||||
const heldWeth = WETH_ADDRESSES.some((w) =>
|
||||
// step paid it. That amount is known when the router
|
||||
// held a known amount of WETH and no ETH before.
|
||||
const heldWeth = WETH_ADDRESSES.filter((w) =>
|
||||
heldByRouter.has(w),
|
||||
);
|
||||
WETH_ADDRESSES.forEach((w) => heldByRouter.delete(w));
|
||||
if (isRouter(u.recipient) && heldWeth) {
|
||||
const ethAmount =
|
||||
heldWeth.length === 1 &&
|
||||
!heldByRouter.has(
|
||||
"0x0000000000000000000000000000000000000000",
|
||||
)
|
||||
? heldByRouter.get(heldWeth[0])
|
||||
: null;
|
||||
heldWeth.forEach((w) => heldByRouter.delete(w));
|
||||
if (isRouter(u.recipient) && heldWeth.length > 0) {
|
||||
heldByRouter.set(
|
||||
"0x0000000000000000000000000000000000000000",
|
||||
null,
|
||||
ethAmount,
|
||||
);
|
||||
}
|
||||
} else {
|
||||
@@ -2201,10 +2071,10 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
// The total is what the steps take of Token In: the amount of the
|
||||
// step that set the input side, with each later take of that token
|
||||
// added to it while both are quantities. A take that cannot be added,
|
||||
// being of another token, coming after an amount that is not a
|
||||
// quantity (a V4 open delta, ALREADY_PAID, or none stated), or having
|
||||
// `atMost` set, gets lines of its own. One whose amount is not known
|
||||
// also leaves the total unknown, with no figure.
|
||||
// being of another token or coming after an amount that is not a
|
||||
// quantity (a V4 open delta, ALREADY_PAID, or none stated), gets
|
||||
// lines of its own. One whose amount is not known also leaves the
|
||||
// total unknown, with no figure.
|
||||
//
|
||||
// A PERMIT2_PERMIT names Token In only when its amount stands as the
|
||||
// Amount figure in place of the total, which it does only in the
|
||||
@@ -2220,14 +2090,12 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
// it may take more. A later permit or batch, or a later step this
|
||||
// decoder did not read, may raise what Permit2 lets the router take.
|
||||
// Every other PERMIT2_PERMIT leaves Token In and the Amount line as
|
||||
// they read with no permit, and gets lines of its own below. A permit
|
||||
// on the zero address never stands as the Amount figure, because
|
||||
// Permit2 has no allowance of ETH. A step that may take from the
|
||||
// sender what this decoder did not read leaves no figure, permit or
|
||||
// not (see spentUnread()), and so do a permit or batch whose input it
|
||||
// cannot read (see permitUnread()) and an allowance of Token In to
|
||||
// another spender (see toAnotherSpender). An EXECUTE_SUB_PLAN step
|
||||
// leaves both sides unknown (below).
|
||||
// they read with no permit, and gets lines of its own below. A step
|
||||
// that may take from the sender what this decoder did not read leaves
|
||||
// no figure, permit or not (see spentUnread()), and so do a permit
|
||||
// or batch whose input it cannot read (see permitUnread()) and an
|
||||
// allowance of Token In to another spender (see toAnotherSpender). An
|
||||
// EXECUTE_SUB_PLAN step leaves both sides unknown (below).
|
||||
const stepCommands = Array.from(
|
||||
commandsBytes,
|
||||
(b) => commands[b & commandTypeMask],
|
||||
@@ -2237,27 +2105,27 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
stepCommands.filter((c) => c === "PERMIT2_PERMIT").length === 1 &&
|
||||
!stepCommands.includes("PERMIT2_PERMIT_BATCH") &&
|
||||
sameAddress(permit.spender, toAddress) &&
|
||||
permit.token !== "0x0000000000000000000000000000000000000000" &&
|
||||
!permit.allowedToFail &&
|
||||
permit.beforeEveryTake &&
|
||||
!stepsUnread.some((step) => step > permit.step);
|
||||
// What the steps take that the Amount line does not give, as
|
||||
// { token, amount, atMost, recipient }. A null token is a step this
|
||||
// decoder did not read (see spentUnread()), or a token it does not
|
||||
// know. `atMost` is as in `userPaid`. Only the take of a WRAP_ETH that
|
||||
// pays elsewhere has a recipient (see wrapEthRecipient).
|
||||
// { token, amount, recipient }. A null token is a step this decoder
|
||||
// did not read (see spentUnread()), or a token it does not know. Only
|
||||
// the take of a WRAP_ETH that pays elsewhere has a recipient (see
|
||||
// wrapEthRecipient).
|
||||
const spentFromSender = [];
|
||||
let total = null;
|
||||
// The takes from the sender that `total` adds up, each a quantity, in
|
||||
// the shape of `spentFromSender`. When there is no Amount line, each
|
||||
// gets lines of its own (see below). The amount of the step that set
|
||||
// the input side counts in `total` whoever pays that step. That amount
|
||||
// is among them only when the user pays the step (see inputPaidByUser).
|
||||
// gets lines of its own (see below). The amount of a step that set
|
||||
// the input side and is paid from the router counts in `total` but is
|
||||
// not among them.
|
||||
const inTotal = [];
|
||||
// Whether the step that set the input side counts as a take from the
|
||||
// sender, which may get lines of its own. The amount it stated counts
|
||||
// whoever pays it. Stating none, it counts only when the user pays it
|
||||
// some of its input token.
|
||||
// some of its input token: paid from the router, it takes nothing
|
||||
// from the sender.
|
||||
const hasFirstTake =
|
||||
inputEstablished && (present(inputAmount) || inputPaidByUser);
|
||||
// The take of the step that set the input side, when the total
|
||||
@@ -2291,8 +2159,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
if (
|
||||
ofTokenIn &&
|
||||
typeof total === "bigint" &&
|
||||
typeof t.amount === "bigint" &&
|
||||
!t.atMost
|
||||
typeof t.amount === "bigint"
|
||||
) {
|
||||
total += t.amount;
|
||||
inTotal.push(t);
|
||||
@@ -2341,11 +2208,11 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
// Any other output keeps its own token and figure: a swap that pays
|
||||
// its WETH to the user and then unwraps receives WETH, and one that
|
||||
// buys USDC and then unwraps the WETH it did not spend receives USDC.
|
||||
const inInfo = tokenInfo(inputToken, tokenSources);
|
||||
const inInfo = tokenInfo(inputToken, sources);
|
||||
const outInfo =
|
||||
outputUnwrapped || (hasUnwrapWeth && !outputEstablished)
|
||||
? { symbol: "ETH", decimals: 18, address: null }
|
||||
: tokenInfo(outputToken, tokenSources);
|
||||
: tokenInfo(outputToken, sources);
|
||||
|
||||
const inSymbol = inInfo.symbol;
|
||||
const outSymbol = outInfo.symbol;
|
||||
@@ -2395,9 +2262,8 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
// V2's already-paid zero, neither of which is a quantity at all (see
|
||||
// OPEN_DELTA and ALREADY_PAID), and an unbounded permit. Those two
|
||||
// tests come first — the sentinels are not bigints and cannot be
|
||||
// compared with one. `atMost` marks an amount that is only the most a
|
||||
// take may be (see userPaid).
|
||||
const spentText = (amount, info, atMost) => {
|
||||
// compared with one.
|
||||
const spentText = (amount, info) => {
|
||||
if (amount === OPEN_DELTA) {
|
||||
return { raw: OPEN_DELTA_AMOUNT, display: OPEN_DELTA_AMOUNT };
|
||||
}
|
||||
@@ -2410,7 +2276,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
if (amount >= MAX_UINT160) {
|
||||
return { raw: "Unlimited", display: "Unlimited" };
|
||||
}
|
||||
if (hasV2OrV3ExactOut || atMost) {
|
||||
if (hasV2OrV3ExactOut) {
|
||||
// A V2 or V3 exact-out swap spends at most this figure,
|
||||
// whichever steps gave it (an amountInMax, the WRAP_ETH of a
|
||||
// swap paid in ETH, a permit, or several steps' total), so it
|
||||
@@ -2437,19 +2303,17 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
// A null token in `spentFromSender`, a step this decoder did not read
|
||||
// or a token it does not know, and an allowance to another spender
|
||||
// that may be of Token In, leave no Amount figure, which may then be
|
||||
// too low. An allowance of the zero address is never one of Token In,
|
||||
// because Permit2 has no allowance of ETH. With no Amount line, each
|
||||
// take the total adds up gets lines of its own, first, so that every
|
||||
// amount this decoder read is shown.
|
||||
// too low. With no Amount line, each take the total adds up gets
|
||||
// lines of its own, first, so that every amount this decoder read is
|
||||
// shown.
|
||||
if (
|
||||
present(inputAmount) &&
|
||||
spentFromSender.every((s) => present(s.token)) &&
|
||||
toAnotherSpender.every(
|
||||
(p) =>
|
||||
p.token === "0x0000000000000000000000000000000000000000" ||
|
||||
(present(p.token) &&
|
||||
present(p.token) &&
|
||||
present(inputToken) &&
|
||||
!sameAddress(p.token, inputToken)),
|
||||
!sameAddress(p.token, inputToken),
|
||||
)
|
||||
) {
|
||||
const amount = spentText(inputAmount, inInfo);
|
||||
@@ -2472,20 +2336,11 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
details.push({
|
||||
label: "Moved from the sender",
|
||||
value: present(s.amount)
|
||||
? spentText(
|
||||
s.amount,
|
||||
tokenInfo(s.token, tokenSources),
|
||||
s.atMost,
|
||||
).display
|
||||
? spentText(s.amount, tokenInfo(s.token, sources)).display
|
||||
: UNDECODED_CURRENCY,
|
||||
});
|
||||
if (present(s.token)) {
|
||||
details.push(
|
||||
tokenMovedLine(
|
||||
"Token moved",
|
||||
tokenInfo(s.token, tokenSources),
|
||||
),
|
||||
);
|
||||
details.push(tokenMovedLine("Token moved", s.token, sources));
|
||||
if (!present(s.recipient)) {
|
||||
details.push({
|
||||
label: "Moved to",
|
||||
@@ -2506,12 +2361,12 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
// What each PERMIT2_TRANSFER_FROM moves: its amount, its token and
|
||||
// where it goes, an address on a line of its own.
|
||||
for (const m of movedFromSender) {
|
||||
const info = permit2TokenInfo(m.token, tokenSources);
|
||||
details.push({
|
||||
label: "Moved from the sender",
|
||||
value: amountText(m.amount, info).display,
|
||||
value: amountText(m.amount, tokenInfo(m.token, sources))
|
||||
.display,
|
||||
});
|
||||
details.push(tokenMovedLine("Token moved", info));
|
||||
details.push(tokenMovedLine("Token moved", m.token, sources));
|
||||
details.push(
|
||||
present(m.to)
|
||||
? { label: "Moved to", value: m.to }
|
||||
@@ -2541,15 +2396,15 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
});
|
||||
continue;
|
||||
}
|
||||
const info = permit2TokenInfo(p.token, tokenSources);
|
||||
details.push({
|
||||
label: "Permit2 allowance",
|
||||
value:
|
||||
p.amount >= MAX_UINT160
|
||||
? "Unlimited"
|
||||
: amountText(p.amount, info).display,
|
||||
: amountText(p.amount, tokenInfo(p.token, sources))
|
||||
.display,
|
||||
});
|
||||
details.push(tokenMovedLine("Allowance token", info));
|
||||
details.push(tokenMovedLine("Allowance token", p.token, sources));
|
||||
details.push({
|
||||
label: "Allowance spender",
|
||||
value: p.spender,
|
||||
@@ -2607,7 +2462,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
paidTo.push({ label: "Paid to", value: PAID_TO_BRIDGE });
|
||||
}
|
||||
for (const m of movedIntoRouter) {
|
||||
const info = permit2TokenInfo(m.token, tokenSources);
|
||||
const info = tokenInfo(m.token, sources);
|
||||
paidTo.push({
|
||||
label: "Paid to",
|
||||
value:
|
||||
@@ -2615,7 +2470,9 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
amountText(m.amount, info).display +
|
||||
" from the sender (later steps may not spend all of it)",
|
||||
});
|
||||
paidTo.push(tokenMovedLine("Token moved into the router", info));
|
||||
paidTo.push(
|
||||
tokenMovedLine("Token moved into the router", m.token, sources),
|
||||
);
|
||||
}
|
||||
if (outputHeld) {
|
||||
paidTo.push({ label: "Paid to", value: STAYS_IN_ROUTER });
|
||||
@@ -2632,7 +2489,8 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
paidTo.push(
|
||||
tokenMovedLine(
|
||||
"Token moved into the router",
|
||||
tokenInfo(getAddress(token), tokenSources),
|
||||
getAddress(token),
|
||||
sources,
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
@@ -1,138 +0,0 @@
|
||||
// A contract lookup on AddToken can answer after the user has left AddToken.
|
||||
// The token is still added, and the screen the user is on does not change
|
||||
// (https://git.eeqj.de/sneak/AutistMask/issues/603). An answer while AddToken
|
||||
// still shows goes to AddressDetail. Driven through the real popup over a
|
||||
// stored profile.
|
||||
|
||||
const {
|
||||
bootPopup,
|
||||
cleanupPopup,
|
||||
unversionedValidProfile,
|
||||
TOKEN_ADDRESS,
|
||||
} = require("./support/popupBoot");
|
||||
|
||||
const TOKEN = {
|
||||
address: TOKEN_ADDRESS,
|
||||
symbol: "TST",
|
||||
decimals: 18,
|
||||
name: "Test Token",
|
||||
balanceNotFetched: true,
|
||||
};
|
||||
|
||||
// A second contract address, typed after AddToken was opened again.
|
||||
const OTHER_TOKEN_ADDRESS = "0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB";
|
||||
|
||||
afterEach(() => {
|
||||
cleanupPopup();
|
||||
});
|
||||
|
||||
// The popup reopened onto AddressDetail, then AddToken opened from it with
|
||||
// TOKEN's contract address typed in.
|
||||
async function openAddToken() {
|
||||
const boot = await bootPopup(
|
||||
unversionedValidProfile({
|
||||
currentView: "address",
|
||||
selectedWallet: 0,
|
||||
selectedAddress: 0,
|
||||
}),
|
||||
);
|
||||
expect(boot.pageErrors).toEqual([]);
|
||||
await boot.click("btn-add-token");
|
||||
expect(boot.visibleViews()).toEqual(["add-token"]);
|
||||
boot.node("add-token-address").value = TOKEN.address;
|
||||
return boot;
|
||||
}
|
||||
|
||||
// Presses Add with a contract lookup that answers only when the function
|
||||
// returned here is called. That function waits for Add to finish.
|
||||
function addWithPendingLookup(boot) {
|
||||
const { lookupTokenInfo } = require("../src/shared/balances");
|
||||
let answer;
|
||||
lookupTokenInfo.mockImplementationOnce(
|
||||
() =>
|
||||
new Promise((resolve) => {
|
||||
answer = resolve;
|
||||
}),
|
||||
);
|
||||
const adding = boot.click("btn-add-token-confirm");
|
||||
return async () => {
|
||||
answer({
|
||||
symbol: TOKEN.symbol,
|
||||
decimals: TOKEN.decimals,
|
||||
name: TOKEN.name,
|
||||
});
|
||||
await adding;
|
||||
};
|
||||
}
|
||||
|
||||
test("an answer after the user opened Settings adds the token and Settings stays", async () => {
|
||||
const boot = await openAddToken();
|
||||
const answerLookup = addWithPendingLookup(boot);
|
||||
await boot.click("btn-settings");
|
||||
expect(boot.visibleViews()).toEqual(["settings"]);
|
||||
|
||||
await answerLookup();
|
||||
expect(boot.visibleViews()).toEqual(["settings"]);
|
||||
expect(boot.storage.read("autistmask").trackedTokens).toEqual([TOKEN]);
|
||||
});
|
||||
|
||||
test("Back from Settings onto AddToken after the lookup answered shows no lookup status", async () => {
|
||||
const boot = await openAddToken();
|
||||
const answerLookup = addWithPendingLookup(boot);
|
||||
expect(boot.text("add-token-info")).toBe("Looking up token...");
|
||||
await boot.click("btn-settings");
|
||||
await answerLookup();
|
||||
|
||||
await boot.click("btn-settings-back");
|
||||
expect(boot.visibleViews()).toEqual(["add-token"]);
|
||||
expect(boot.text("add-token-info")).toBe("");
|
||||
expect(boot.node("add-token-info").style.visibility).toBe("hidden");
|
||||
});
|
||||
|
||||
test("an answer after AddToken was opened again adds the token and leaves AddToken and its status line as they are", async () => {
|
||||
const boot = await openAddToken();
|
||||
const answerFirstLookup = addWithPendingLookup(boot);
|
||||
await boot.click("btn-add-token-back");
|
||||
await boot.click("btn-add-token");
|
||||
expect(boot.visibleViews()).toEqual(["add-token"]);
|
||||
boot.node("add-token-address").value = OTHER_TOKEN_ADDRESS;
|
||||
// The second lookup is never answered.
|
||||
addWithPendingLookup(boot);
|
||||
|
||||
await answerFirstLookup();
|
||||
expect(boot.visibleViews()).toEqual(["add-token"]);
|
||||
expect(boot.text("add-token-info")).toBe("Looking up token...");
|
||||
expect(boot.storage.read("autistmask").trackedTokens).toEqual([TOKEN]);
|
||||
});
|
||||
|
||||
test("a lookup that fails after AddToken was opened again leaves the status line as it is", async () => {
|
||||
const boot = await openAddToken();
|
||||
const { lookupTokenInfo } = require("../src/shared/balances");
|
||||
let failFirstLookup;
|
||||
lookupTokenInfo.mockImplementationOnce(
|
||||
() =>
|
||||
new Promise((_, reject) => {
|
||||
failFirstLookup = reject;
|
||||
}),
|
||||
);
|
||||
const firstAdd = boot.click("btn-add-token-confirm");
|
||||
await boot.click("btn-add-token-back");
|
||||
await boot.click("btn-add-token");
|
||||
boot.node("add-token-address").value = OTHER_TOKEN_ADDRESS;
|
||||
// The second lookup is never answered.
|
||||
addWithPendingLookup(boot);
|
||||
|
||||
failFirstLookup(new Error("lookup failed"));
|
||||
await firstAdd;
|
||||
expect(boot.text("add-token-info")).toBe("Looking up token...");
|
||||
});
|
||||
|
||||
test("an answer while AddToken still shows goes to AddressDetail with the token listed", async () => {
|
||||
const boot = await openAddToken();
|
||||
const answerLookup = addWithPendingLookup(boot);
|
||||
|
||||
await answerLookup();
|
||||
expect(boot.visibleViews()).toEqual(["address"]);
|
||||
expect(boot.node("address-balances").innerHTML).toContain("TST");
|
||||
expect(boot.storage.read("autistmask").trackedTokens).toEqual([TOKEN]);
|
||||
});
|
||||
@@ -1,458 +0,0 @@
|
||||
// After "Add" on AddToken, AddressDetail lists the new token. Its line reads
|
||||
// `quantity unknown`, not 0.0000, until a balance refresh has read the token's
|
||||
// balance at every address, even if the popup closes and opens again
|
||||
// meanwhile. A token added on SettingsAddToken reads the same wherever it is
|
||||
// listed. A refresh that returns draws the balances on AddressDetail or
|
||||
// AddressToken again, so the fetched balance shows without the screen being
|
||||
// reopened (https://git.eeqj.de/sneak/AutistMask/issues/516).
|
||||
//
|
||||
// The tracked token's record carries `balanceNotFetched` until a refresh has
|
||||
// read the token's balance. Removing the token removes that record. A network
|
||||
// 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.
|
||||
//
|
||||
// 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 {
|
||||
bootPopup,
|
||||
cleanupPopup,
|
||||
unversionedValidProfile,
|
||||
} = require("./support/popupBoot");
|
||||
|
||||
// Tracked by nobody until a test adds it.
|
||||
const NEW_TOKEN = "0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB";
|
||||
|
||||
// A holding of a million NEW_TOKEN, as refreshBalances() stores it.
|
||||
const MILLION = {
|
||||
address: NEW_TOKEN,
|
||||
name: "New Token",
|
||||
symbol: "NEW",
|
||||
decimals: 18,
|
||||
balance: "1000000.0",
|
||||
holders: 3,
|
||||
};
|
||||
|
||||
// NEW_TOKEN as "Add" on AddToken tracks it, once a refresh has read its
|
||||
// balance.
|
||||
const NEW_TRACKED = {
|
||||
address: NEW_TOKEN,
|
||||
symbol: "NEW",
|
||||
name: "New Token",
|
||||
decimals: 18,
|
||||
};
|
||||
|
||||
// A token that another popup page tracks.
|
||||
const OTHER_TOKEN = {
|
||||
address: "0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC",
|
||||
symbol: "OTH",
|
||||
name: "Other Token",
|
||||
decimals: 18,
|
||||
};
|
||||
|
||||
afterEach(() => {
|
||||
cleanupPopup();
|
||||
});
|
||||
|
||||
// The popup reopened onto AddressDetail for the one address.
|
||||
function bootOnAddress(extra) {
|
||||
return bootPopup(
|
||||
unversionedValidProfile({
|
||||
currentView: "address",
|
||||
selectedWallet: 0,
|
||||
selectedAddress: 0,
|
||||
...extra,
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
// Holds the next balance refresh open. The returned function lets it finish
|
||||
// with the address's ETH balance at 2 and `tokenBalances` as its token
|
||||
// entries, having read the balance of every token tracked when it started.
|
||||
// Given null, it finishes having read no token's balance, as when every
|
||||
// balanceOf fails, and leaves the token entries as they were.
|
||||
function holdNextRefresh(page) {
|
||||
const { refreshBalances } = require("../src/shared/balances");
|
||||
let release;
|
||||
refreshBalances.mockImplementationOnce(
|
||||
async (wallets, rpcUrl, explorerUrl, trackedTokens) => {
|
||||
const read = trackedTokens.map((t) => t.address.toLowerCase());
|
||||
const tokenBalances = await new Promise((resolve) => {
|
||||
release = resolve;
|
||||
});
|
||||
wallets[0].addresses[0].balance = "2.0";
|
||||
if (tokenBalances === null) return [];
|
||||
wallets[0].addresses[0].tokenBalances = tokenBalances;
|
||||
return read;
|
||||
},
|
||||
);
|
||||
return async (tokenBalances) => {
|
||||
release(tokenBalances);
|
||||
await page.settle();
|
||||
};
|
||||
}
|
||||
|
||||
// Runs the ten-second refresh to the end, finishing it as holdNextRefresh()
|
||||
// does with `tokenBalances`.
|
||||
async function refreshOnce(page, tokenBalances) {
|
||||
const finish = holdNextRefresh(page);
|
||||
const ticking = page.tick();
|
||||
await page.settle();
|
||||
await finish(tokenBalances);
|
||||
await ticking;
|
||||
}
|
||||
|
||||
// "+ Token", NEW_TOKEN typed in, and "Add", with the contract lookup
|
||||
// answering at once.
|
||||
async function addNewToken(page) {
|
||||
const { lookupTokenInfo } = require("../src/shared/balances");
|
||||
lookupTokenInfo.mockResolvedValueOnce({
|
||||
symbol: "NEW",
|
||||
decimals: 18,
|
||||
name: "New Token",
|
||||
});
|
||||
await page.click("btn-add-token");
|
||||
page.node("add-token-address").value = NEW_TOKEN;
|
||||
await page.click("btn-add-token-confirm");
|
||||
}
|
||||
|
||||
// Settings' "+ Add token", NEW_TOKEN typed in, and "Add", with the contract
|
||||
// lookup answering at once. It ends on SettingsAddToken.
|
||||
async function addOnSettingsAddToken(page) {
|
||||
const { lookupTokenInfo } = require("../src/shared/balances");
|
||||
lookupTokenInfo.mockResolvedValueOnce({
|
||||
symbol: "NEW",
|
||||
decimals: 18,
|
||||
name: "New Token",
|
||||
});
|
||||
await page.click("btn-settings-add-token");
|
||||
page.node("settings-addtoken-address").value = NEW_TOKEN;
|
||||
await page.click("btn-settings-addtoken-manual");
|
||||
}
|
||||
|
||||
// The "[x]" button Settings draws beside the first tracked token. The page
|
||||
// stub does not turn the markup Settings draws into elements. So the list
|
||||
// hands Settings a stand-in for that button each time it is drawn, and
|
||||
// `press()` presses the last one drawn. Call it before Settings opens.
|
||||
function firstRemoveButton(page) {
|
||||
const button = { press: null };
|
||||
page.node("settings-tracked-tokens").querySelectorAll = () => [
|
||||
{
|
||||
dataset: { idx: "0" },
|
||||
addEventListener: (name, fn) => {
|
||||
button.press = fn;
|
||||
},
|
||||
},
|
||||
];
|
||||
return button;
|
||||
}
|
||||
|
||||
// Picks `networkId` in the Settings network selector, as the user does.
|
||||
async function chooseNetwork(page, networkId) {
|
||||
const select = page.node("settings-network");
|
||||
select.value = networkId;
|
||||
for (const fn of select.listeners.change) await fn();
|
||||
await page.settle();
|
||||
}
|
||||
|
||||
// Another popup page saves `trackedTokens` as the tracked token list. This
|
||||
// page is not told of the write.
|
||||
function anotherPageTracks(page, trackedTokens) {
|
||||
page.storage.write("autistmask", {
|
||||
...page.storage.read("autistmask"),
|
||||
trackedTokens,
|
||||
});
|
||||
}
|
||||
|
||||
// NEW_TOKEN's row in the balance list in element `id`, AddressDetail's unless
|
||||
// another is named, as markup.
|
||||
function newTokenRow(page, id = "address-balances") {
|
||||
return page
|
||||
.node(id)
|
||||
.innerHTML.split("<div ")
|
||||
.find((row) =>
|
||||
row.includes('data-token="' + NEW_TOKEN.toLowerCase() + '"'),
|
||||
);
|
||||
}
|
||||
|
||||
// AddressDetail for the one address opened from Home, as its `[info]` button
|
||||
// does.
|
||||
async function openAddress(page) {
|
||||
const { state } = require("../src/shared/state");
|
||||
state.selectedWallet = 0;
|
||||
state.selectedAddress = 0;
|
||||
require("../src/popup/views/helpers").pushCurrentView();
|
||||
require("../src/popup/views/addressDetail").show();
|
||||
await page.settle();
|
||||
}
|
||||
|
||||
// AddressToken for `token` opened from AddressDetail, as tapping the token's
|
||||
// row there does.
|
||||
async function openToken(page, token) {
|
||||
const { state } = require("../src/shared/state");
|
||||
state.selectedToken = token;
|
||||
require("../src/popup/views/helpers").pushCurrentView();
|
||||
require("../src/popup/views/addressToken").show();
|
||||
await page.settle();
|
||||
}
|
||||
|
||||
test("until the refresh Add started returns, the new token's line reads quantity unknown", async () => {
|
||||
const page = await bootOnAddress();
|
||||
expect(page.pageErrors).toEqual([]);
|
||||
const finish = holdNextRefresh(page);
|
||||
|
||||
await addNewToken(page);
|
||||
|
||||
expect(page.visibleViews()).toEqual(["address"]);
|
||||
const row = newTokenRow(page);
|
||||
expect(row).toContain("quantity unknown");
|
||||
expect(row).not.toContain("0.0000");
|
||||
await finish([MILLION]);
|
||||
});
|
||||
|
||||
test("once that refresh returns, AddressDetail shows the fetched balance without being reopened", async () => {
|
||||
const page = await bootOnAddress();
|
||||
const finish = holdNextRefresh(page);
|
||||
await addNewToken(page);
|
||||
// Stands for the transactions on the screen, which only show() replaces.
|
||||
page.node("tx-list").innerHTML = "transactions on the screen";
|
||||
|
||||
await finish([MILLION]);
|
||||
|
||||
expect(page.visibleViews()).toEqual(["address"]);
|
||||
expect(newTokenRow(page)).toContain("1000000.0000");
|
||||
// Only the balances are drawn again, not the transaction list.
|
||||
expect(page.node("tx-list").innerHTML).toBe("transactions on the screen");
|
||||
});
|
||||
|
||||
test("a refresh already running when the token is added does not count as reading its balance", async () => {
|
||||
const page = await bootOnAddress();
|
||||
const finishRunning = holdNextRefresh(page);
|
||||
const ticking = page.tick();
|
||||
await page.settle();
|
||||
|
||||
await addNewToken(page);
|
||||
await finishRunning([]);
|
||||
await ticking;
|
||||
|
||||
expect(newTokenRow(page)).toContain("quantity unknown");
|
||||
|
||||
// The next one reads the token's balance, which is zero.
|
||||
await refreshOnce(page, []);
|
||||
|
||||
expect(newTokenRow(page)).toContain("0.0000");
|
||||
});
|
||||
|
||||
test("closed and opened again before any refresh has read its balance, the new token's line still reads quantity unknown", async () => {
|
||||
const closed = await bootOnAddress();
|
||||
holdNextRefresh(closed);
|
||||
await addNewToken(closed);
|
||||
cleanupPopup();
|
||||
|
||||
// The refresh this boot starts reads no token's balance: the boot's stub
|
||||
// of refreshBalances() reads none.
|
||||
const page = await bootPopup(undefined, { storage: closed.storage });
|
||||
expect(page.visibleViews()).toEqual(["address"]);
|
||||
const row = newTokenRow(page);
|
||||
expect(row).toContain("quantity unknown");
|
||||
expect(row).not.toContain("0.0000");
|
||||
|
||||
await refreshOnce(page, [MILLION]);
|
||||
|
||||
expect(newTokenRow(page)).toContain("1000000.0000");
|
||||
});
|
||||
|
||||
test("a refresh that could not read the new token's balance leaves its line quantity unknown", async () => {
|
||||
const page = await bootOnAddress();
|
||||
const finish = holdNextRefresh(page);
|
||||
await addNewToken(page);
|
||||
|
||||
await finish(null);
|
||||
|
||||
// Drawn again: the ETH balance it fetched is shown.
|
||||
expect(page.node("address-balances").innerHTML).toContain("2.0000");
|
||||
expect(newTokenRow(page)).toContain("quantity unknown");
|
||||
});
|
||||
|
||||
test("AddressToken for the new token reads quantity unknown until the refresh returns, then the fetched balance", async () => {
|
||||
const page = await bootOnAddress();
|
||||
const finish = holdNextRefresh(page);
|
||||
await addNewToken(page);
|
||||
|
||||
await openToken(page, NEW_TOKEN.toLowerCase());
|
||||
|
||||
expect(page.visibleViews()).toEqual(["address-token"]);
|
||||
const before = page.node("address-token-balance").innerHTML;
|
||||
expect(before).toContain("quantity unknown");
|
||||
expect(before).not.toContain("0.0000");
|
||||
|
||||
await finish([MILLION]);
|
||||
|
||||
expect(page.node("address-token-balance").innerHTML).toContain(
|
||||
"1000000.0000",
|
||||
);
|
||||
});
|
||||
|
||||
test("Send for the new token reads its balance as unknown before any refresh has read it, and Max says so", async () => {
|
||||
const page = await bootOnAddress();
|
||||
const finish = holdNextRefresh(page);
|
||||
await addNewToken(page);
|
||||
await openToken(page, NEW_TOKEN.toLowerCase());
|
||||
|
||||
await page.click("btn-address-token-send");
|
||||
|
||||
expect(page.visibleViews()).toEqual(["send"]);
|
||||
expect(page.text("send-balance")).toBe("Current balance: unknown (NEW)");
|
||||
|
||||
await page.click("btn-send-max");
|
||||
|
||||
expect(page.text("flash-msg")).toBe("This token's balance is unknown.");
|
||||
await finish([MILLION]);
|
||||
});
|
||||
|
||||
test("a token added by contract address on SettingsAddToken reads quantity unknown until the refresh returns", async () => {
|
||||
const page = await bootPopup(unversionedValidProfile());
|
||||
expect(page.visibleViews()).toEqual(["main"]);
|
||||
const finish = holdNextRefresh(page);
|
||||
|
||||
await page.click("btn-settings");
|
||||
await addOnSettingsAddToken(page);
|
||||
await page.click("btn-settings-addtoken-back");
|
||||
await page.click("btn-settings-back");
|
||||
expect(page.visibleViews()).toEqual(["main"]);
|
||||
const onHome = newTokenRow(page, "wallet-list");
|
||||
expect(onHome).toContain("quantity unknown");
|
||||
expect(onHome).not.toContain("0.0000");
|
||||
|
||||
await openAddress(page);
|
||||
const onAddress = newTokenRow(page);
|
||||
expect(onAddress).toContain("quantity unknown");
|
||||
expect(onAddress).not.toContain("0.0000");
|
||||
|
||||
await finish([MILLION]);
|
||||
|
||||
expect(newTokenRow(page)).toContain("1000000.0000");
|
||||
});
|
||||
|
||||
test("a refresh that returns while AddressToken is up draws its balance again", async () => {
|
||||
const page = await bootPopup(
|
||||
unversionedValidProfile({
|
||||
currentView: "address-token",
|
||||
viewStack: ["main", "address"],
|
||||
selectedWallet: 0,
|
||||
selectedAddress: 0,
|
||||
selectedToken: "ETH",
|
||||
}),
|
||||
);
|
||||
expect(page.visibleViews()).toEqual(["address-token"]);
|
||||
expect(page.node("address-token-balance").innerHTML).toContain("1.5000");
|
||||
|
||||
await refreshOnce(page, null);
|
||||
|
||||
expect(page.node("address-token-balance").innerHTML).toContain("2.0000");
|
||||
});
|
||||
|
||||
test("a token removed before any refresh has read its balance leaves nothing stored, and adding it again tracks it once", async () => {
|
||||
const page = await bootPopup(unversionedValidProfile());
|
||||
const removeButton = firstRemoveButton(page);
|
||||
const stored = () => page.storage.read("autistmask");
|
||||
|
||||
await page.click("btn-settings");
|
||||
await addOnSettingsAddToken(page);
|
||||
// Settings opened again from Home draws its list with the token in it.
|
||||
await page.click("btn-settings-addtoken-back");
|
||||
await page.click("btn-settings-back");
|
||||
await page.click("btn-settings");
|
||||
await removeButton.press();
|
||||
await page.settle();
|
||||
|
||||
expect(stored().trackedTokens).toEqual([]);
|
||||
// Nothing in the stored record names the token any more.
|
||||
expect(JSON.stringify(stored()).toLowerCase()).not.toContain(
|
||||
NEW_TOKEN.toLowerCase(),
|
||||
);
|
||||
|
||||
await addOnSettingsAddToken(page);
|
||||
// A second add of the same token is refused.
|
||||
page.node("settings-addtoken-address").value = NEW_TOKEN;
|
||||
await page.click("btn-settings-addtoken-manual");
|
||||
|
||||
const added = { address: NEW_TOKEN, symbol: "NEW", decimals: 18 };
|
||||
expect(stored().trackedTokens).toEqual([
|
||||
{ ...added, name: "New Token", balanceNotFetched: true },
|
||||
]);
|
||||
|
||||
await refreshOnce(page, []);
|
||||
|
||||
expect(stored().trackedTokens).toEqual([{ ...added, name: "New Token" }]);
|
||||
});
|
||||
|
||||
test("a refresh on another network leaves the new token reading quantity unknown on its own", async () => {
|
||||
// Sepolia tracks a token at the same contract address, also just added.
|
||||
const sepoliaToken = {
|
||||
address: NEW_TOKEN,
|
||||
symbol: "SEP",
|
||||
name: "Sepolia Token",
|
||||
decimals: 18,
|
||||
};
|
||||
const page = await bootOnAddress({
|
||||
networkTrackedTokens: {
|
||||
sepolia: [{ ...sepoliaToken, balanceNotFetched: true }],
|
||||
},
|
||||
});
|
||||
const finishMainnet = holdNextRefresh(page);
|
||||
await addNewToken(page);
|
||||
|
||||
await page.click("btn-settings");
|
||||
await chooseNetwork(page, "sepolia");
|
||||
// The refresh Add started returns after the switch and writes nothing.
|
||||
await finishMainnet([MILLION]);
|
||||
// Sepolia's refresh reads the balance of its own token.
|
||||
await refreshOnce(page, []);
|
||||
|
||||
const stored = page.storage.read("autistmask");
|
||||
expect(stored.trackedTokens).toEqual([sepoliaToken]);
|
||||
expect(stored.networkTrackedTokens.mainnet[0].balanceNotFetched).toBe(true);
|
||||
|
||||
await chooseNetwork(page, "mainnet");
|
||||
await page.click("btn-settings-back");
|
||||
|
||||
expect(page.visibleViews()).toEqual(["address"]);
|
||||
expect(newTokenRow(page)).toContain("quantity unknown");
|
||||
|
||||
await refreshOnce(page, [MILLION]);
|
||||
|
||||
expect(newTokenRow(page)).toContain("1000000.0000");
|
||||
});
|
||||
|
||||
test("a refresh keeps a token that another page added after this page loaded", async () => {
|
||||
const page = await bootOnAddress();
|
||||
const finish = holdNextRefresh(page);
|
||||
await addNewToken(page);
|
||||
const otherAdded = { ...OTHER_TOKEN, balanceNotFetched: true };
|
||||
anotherPageTracks(page, [
|
||||
{ ...NEW_TRACKED, balanceNotFetched: true },
|
||||
otherAdded,
|
||||
]);
|
||||
|
||||
await finish([MILLION]);
|
||||
|
||||
expect(page.storage.read("autistmask").trackedTokens).toEqual([
|
||||
NEW_TRACKED,
|
||||
otherAdded,
|
||||
]);
|
||||
expect(newTokenRow(page)).toContain("1000000.0000");
|
||||
});
|
||||
|
||||
test("a refresh does not bring back a token that another page removed after this page loaded", async () => {
|
||||
const page = await bootOnAddress({ trackedTokens: [OTHER_TOKEN] });
|
||||
const finish = holdNextRefresh(page);
|
||||
await addNewToken(page);
|
||||
anotherPageTracks(page, [{ ...NEW_TRACKED, balanceNotFetched: true }]);
|
||||
|
||||
await finish([MILLION]);
|
||||
|
||||
expect(page.storage.read("autistmask").trackedTokens).toEqual([
|
||||
NEW_TRACKED,
|
||||
]);
|
||||
});
|
||||
@@ -161,7 +161,7 @@ function click(element) {
|
||||
|
||||
// show() starts the fee estimate without awaiting it; this lets it settle.
|
||||
async function settle() {
|
||||
for (let i = 0; i < 10; i++) await jest.advanceTimersByTimeAsync(0);
|
||||
for (let i = 0; i < 10; i++) await new Promise((r) => setTimeout(r, 0));
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------ harness
|
||||
@@ -188,11 +188,7 @@ let sent;
|
||||
// handler to the buttons it drew, as the browser's fresh list would have.
|
||||
let plusButton;
|
||||
|
||||
// showFlash() starts a timer that clears the message one or two seconds later.
|
||||
// Each test here runs on fake timers and drops them in afterEach, so that timer
|
||||
// never outlives the test.
|
||||
beforeEach(() => {
|
||||
jest.useFakeTimers();
|
||||
approvalDetails = null;
|
||||
sent = [];
|
||||
mockNode.broadcast = [];
|
||||
@@ -243,7 +239,6 @@ beforeEach(() => {
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
jest.useRealTimers();
|
||||
jest.restoreAllMocks();
|
||||
});
|
||||
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
// The USD total of an address that holds something this build cannot price
|
||||
// (issue #261).
|
||||
//
|
||||
// Only a token with a price feed has a price, so an address can hold real
|
||||
// assets with no price attached. Summing what is priced and printing the result
|
||||
// as the total says "$0.00" for an address holding nothing but unpriced tokens —
|
||||
// Prices exist for the top 25 tokens only, so an address can hold real assets
|
||||
// with no price attached. Summing what is priced and printing the result as
|
||||
// the total says "$0.00" for an address holding nothing but unpriced tokens —
|
||||
// worth-nothing and worth-an-unknown-amount collapsed into one number, in the
|
||||
// direction that matters. The two are separate facts here, the same way an
|
||||
// absent holders_count is not a count of zero.
|
||||
@@ -63,7 +63,7 @@ const PARTLY_PRICED = {
|
||||
beforeEach(() => {
|
||||
clearPrices();
|
||||
prices.ETH = 2000;
|
||||
prices[USDC] = 1;
|
||||
prices.USDC = 1;
|
||||
state.wallets = [];
|
||||
state.trackedTokens = [];
|
||||
state.showZeroBalanceTokens = false;
|
||||
|
||||
@@ -90,11 +90,9 @@ beforeEach(() => {
|
||||
});
|
||||
|
||||
describe("resolveTokenDecimals", () => {
|
||||
// The bundled list is read only for a token on Ethereum Mainnet.
|
||||
test("prefers the bundled list", () => {
|
||||
state.trackedTokens = [{ address: USDC, symbol: "USDC", decimals: 2 }];
|
||||
const sources = { chainId: "0x1", trackedTokens: state.trackedTokens };
|
||||
expect(resolveTokenDecimals(USDC, sources)).toBe(6);
|
||||
expect(resolveTokenDecimals(USDC, state)).toBe(6);
|
||||
});
|
||||
|
||||
test("reads a token the user tracks", () => {
|
||||
@@ -126,8 +124,7 @@ describe("resolveTokenDecimals", () => {
|
||||
// answers 0 is used rather than fallen past like the unusable entry above.
|
||||
test("uses a bundled scale of zero", () => {
|
||||
state.trackedTokens = [{ address: SLP, symbol: "SLP", decimals: 18 }];
|
||||
const sources = { chainId: "0x1", trackedTokens: state.trackedTokens };
|
||||
expect(resolveTokenDecimals(SLP, sources)).toBe(0);
|
||||
expect(resolveTokenDecimals(SLP, state)).toBe(0);
|
||||
});
|
||||
|
||||
test("uses a tracked scale of zero", () => {
|
||||
|
||||
@@ -1,169 +0,0 @@
|
||||
// The approval screen for a site's Sepolia transfer of the contract at USDC's
|
||||
// mainnet address, while Sepolia is active.
|
||||
//
|
||||
// The bundled token list holds Ethereum Mainnet contracts. The contract at the
|
||||
// same address on Sepolia is another token, but the screen named it USDC and
|
||||
// scaled its amount at USDC's decimals
|
||||
// (https://git.eeqj.de/sneak/AutistMask/issues/632). The bundled list now names
|
||||
// a token only on Ethereum Mainnet. The same screen for a mainnet transfer of
|
||||
// USDC, while Sepolia is active, still names USDC.
|
||||
//
|
||||
// Driven through the real approval screen, against the minimal DOM stub
|
||||
// tests/approvalTokenNetwork.test.js uses.
|
||||
|
||||
globalThis.chrome = {
|
||||
storage: { local: { get: async () => ({}), set: async () => {} } },
|
||||
};
|
||||
|
||||
const { Interface } = require("ethers");
|
||||
const { state } = require("../src/shared/state");
|
||||
const { NETWORKS } = require("../src/shared/networks");
|
||||
const approval = require("../src/popup/views/approval");
|
||||
|
||||
const FROM = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266";
|
||||
const RECIPIENT = "0x711e691962E5c054b78071C789A0C8CE657377aD";
|
||||
// USDC's address on Ethereum Mainnet, where the bundled list names it.
|
||||
const USDC = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
|
||||
|
||||
// FROM sends 1234500000 base units to RECIPIENT.
|
||||
const TRANSFER_DATA = new Interface([
|
||||
"function transfer(address to, uint256 amount)",
|
||||
]).encodeFunctionData("transfer", [RECIPIENT, 1234500000n]);
|
||||
|
||||
function makeElement(id) {
|
||||
const classes = new Set();
|
||||
const el = {
|
||||
id,
|
||||
textContent: "",
|
||||
value: "",
|
||||
innerHTML: "",
|
||||
disabled: false,
|
||||
style: {},
|
||||
dataset: {},
|
||||
listeners: {},
|
||||
classList: {
|
||||
add: (...names) => names.forEach((n) => classes.add(n)),
|
||||
remove: (...names) => names.forEach((n) => classes.delete(n)),
|
||||
contains: (n) => classes.has(n),
|
||||
toggle: (n, force) => {
|
||||
const on = force === undefined ? !classes.has(n) : force;
|
||||
if (on) classes.add(n);
|
||||
else classes.delete(n);
|
||||
return on;
|
||||
},
|
||||
},
|
||||
addEventListener: (name, fn) => {
|
||||
el.listeners[name] = el.listeners[name] || [];
|
||||
el.listeners[name].push(fn);
|
||||
},
|
||||
querySelectorAll: () => [],
|
||||
appendChild: () => {},
|
||||
};
|
||||
// Views reach for .parentElement to hide whole sections.
|
||||
Object.defineProperty(el, "parentElement", {
|
||||
get: () => node(id + "-parent"),
|
||||
});
|
||||
return el;
|
||||
}
|
||||
|
||||
function makeDocument() {
|
||||
const els = new Map();
|
||||
return {
|
||||
getElementById(id) {
|
||||
// The debug banner is created on demand by helpers.js; absent
|
||||
// is the state a non-debug, non-testnet popup is in.
|
||||
if (id === "debug-banner") return null;
|
||||
if (!els.has(id)) els.set(id, makeElement(id));
|
||||
return els.get(id);
|
||||
},
|
||||
createElement: () => makeElement("created"),
|
||||
body: { prepend: () => {} },
|
||||
};
|
||||
}
|
||||
|
||||
function node(id) {
|
||||
return globalThis.document.getElementById(id);
|
||||
}
|
||||
|
||||
// One line of the decoded details: its label and what is drawn under it.
|
||||
function decodedLine(label) {
|
||||
return node("approve-tx-decoded-details")
|
||||
.innerHTML.split('<div class="mb-2">')
|
||||
.find((line) =>
|
||||
line.startsWith(`<div class="text-muted">${label}</div>`),
|
||||
);
|
||||
}
|
||||
|
||||
// Open the approval screen, with Sepolia active, for the site's transaction
|
||||
// sending TRANSFER_DATA to the contract at USDC's address on the network with
|
||||
// chain id `chainId`.
|
||||
async function showTransfer(chainId) {
|
||||
globalThis.document = makeDocument();
|
||||
globalThis.window = { location: { search: "" }, close: () => {} };
|
||||
globalThis.chrome.runtime = {
|
||||
connect: () => ({ postMessage: () => {} }),
|
||||
sendMessage: (msg, reply) => {
|
||||
if (!reply) return;
|
||||
reply({
|
||||
type: "tx",
|
||||
origin: "https://dapp.example",
|
||||
isPhishingDomain: false,
|
||||
approvedFrom: FROM,
|
||||
approvedTx: {
|
||||
type: 2,
|
||||
from: FROM,
|
||||
chainId,
|
||||
nonce: "0x7",
|
||||
gasLimit: "0x30d40",
|
||||
maxPriorityFeePerGas: "0x3b9aca00",
|
||||
maxFeePerGas: "0x77359400",
|
||||
to: USDC,
|
||||
value: "0x0",
|
||||
data: TRANSFER_DATA,
|
||||
accessList: [],
|
||||
},
|
||||
});
|
||||
},
|
||||
};
|
||||
state.networkId = "sepolia";
|
||||
state.trackedTokens = [];
|
||||
state.networkTrackedTokens = {};
|
||||
state.activeAddress = FROM;
|
||||
state.wallets = [
|
||||
{
|
||||
type: "hd",
|
||||
name: "Wallet 1",
|
||||
xpub: "xpub-wallet-1",
|
||||
encryptedSecret: "encrypted-secret-1",
|
||||
nextIndex: 1,
|
||||
addresses: [
|
||||
{ address: FROM, index: 0, balance: "0", tokenBalances: [] },
|
||||
],
|
||||
},
|
||||
];
|
||||
state.currentView = null;
|
||||
approval.init({});
|
||||
await approval.show(1);
|
||||
}
|
||||
|
||||
test("names no token, and states the amount in base units", async () => {
|
||||
await showTransfer(NETWORKS.sepolia.chainId);
|
||||
expect(state.currentView).toBe("approve-tx");
|
||||
expect(node("approve-tx-to").innerHTML).not.toContain("USDC");
|
||||
expect(decodedLine("Token")).toContain(
|
||||
'<div class="font-bold">Unknown token</div>',
|
||||
);
|
||||
expect(decodedLine("Amount")).toContain(
|
||||
'<div class="font-bold">1234500000 base units (decimals unknown)</div>',
|
||||
);
|
||||
});
|
||||
|
||||
// A transaction is named for its own network, not the active one.
|
||||
test("a mainnet transfer of USDC is still named and scaled as USDC", async () => {
|
||||
await showTransfer(NETWORKS.mainnet.chainId);
|
||||
expect(state.currentView).toBe("approve-tx");
|
||||
expect(decodedLine("Token")).toContain('<div class="font-bold">USDC</div>');
|
||||
expect(decodedLine("Amount")).toContain(
|
||||
'<div class="font-bold">1234.5000 USDC</div>',
|
||||
);
|
||||
});
|
||||
@@ -537,18 +537,7 @@ async function settleIncludingRejections() {
|
||||
await new Promise((resolve) => setImmediate(resolve));
|
||||
}
|
||||
|
||||
// While an approval is pending, the background starts a 20-second timer to
|
||||
// keep itself running. The timer is stubbed and never starts, so no test in
|
||||
// this file leaves it running.
|
||||
let keepRunningTimer;
|
||||
beforeEach(() => {
|
||||
keepRunningTimer = jest
|
||||
.spyOn(global, "setInterval")
|
||||
.mockImplementation(() => 1);
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
keepRunningTimer.mockRestore();
|
||||
delete global.chrome;
|
||||
jest.resetModules();
|
||||
});
|
||||
@@ -1894,6 +1883,18 @@ describe("a closed approval window leaves the request pending", () => {
|
||||
return bg.actionPopups[bg.actionPopups.length - 1];
|
||||
}
|
||||
|
||||
// The timer that keeps the worker running while an approval is pending is
|
||||
// stubbed, so no test here leaves that timer running when it ends.
|
||||
let keepRunningTimer;
|
||||
beforeEach(() => {
|
||||
keepRunningTimer = jest
|
||||
.spyOn(global, "setInterval")
|
||||
.mockImplementation(() => 1);
|
||||
});
|
||||
afterEach(() => {
|
||||
keepRunningTimer.mockRestore();
|
||||
});
|
||||
|
||||
test("the toolbar popup opens a closed transaction approval, and approving it there sends", async () => {
|
||||
const bg = loadBackground();
|
||||
const pending = bg.requestTx();
|
||||
|
||||
@@ -103,18 +103,7 @@ function deferred() {
|
||||
return { promise, resolve };
|
||||
}
|
||||
|
||||
// While an approval is pending, the background starts a 20-second timer to
|
||||
// keep itself running. The timer is stubbed and never starts, so no test in
|
||||
// this file leaves it running.
|
||||
let keepRunningTimer;
|
||||
beforeEach(() => {
|
||||
keepRunningTimer = jest
|
||||
.spyOn(global, "setInterval")
|
||||
.mockImplementation(() => 1);
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
keepRunningTimer.mockRestore();
|
||||
delete global.chrome;
|
||||
});
|
||||
|
||||
|
||||
@@ -6,10 +6,6 @@
|
||||
// approved a site's request, which changes only the stored record. Driven
|
||||
// through the real popup over a stored profile on Ethereum Mainnet. The same
|
||||
// refresh in the background is in tests/backgroundStateIsolation.test.js.
|
||||
//
|
||||
// The last test covers a balance refresh by the background that is saved while
|
||||
// a switch in Settings waits for the lock
|
||||
// (https://git.eeqj.de/sneak/AutistMask/issues/653).
|
||||
|
||||
const {
|
||||
bootPopup,
|
||||
@@ -45,7 +41,6 @@ async function holdRefresh(page) {
|
||||
holders: null,
|
||||
},
|
||||
];
|
||||
return [];
|
||||
});
|
||||
const ticking = page.tick();
|
||||
await page.settle();
|
||||
@@ -164,50 +159,3 @@ test("a refresh that returns after the background switched the network writes no
|
||||
|
||||
expectNothingStored(page);
|
||||
});
|
||||
|
||||
// The background's refresh saves Ethereum Mainnet's balances while the switch
|
||||
// in Settings waits for the lock. This page last saved a balance of "0" and no
|
||||
// token balances, the values that the switch sets.
|
||||
test("a background refresh saved while a switch in Settings waits for the lock leaves none of its balances stored", async () => {
|
||||
const profile = unversionedValidProfile();
|
||||
profile.wallets[0].addresses[0].balance = "0";
|
||||
const page = await bootPopup(profile);
|
||||
expect(page.pageErrors).toEqual([]);
|
||||
const background = require("../src/background/state");
|
||||
await page.click("btn-settings");
|
||||
|
||||
// The background takes the lock first and holds it until the test calls
|
||||
// `letGo()`. It then saves balances as backgroundRefresh() in
|
||||
// src/background/index.js does.
|
||||
let letGo;
|
||||
const refreshSave = background.updateState(async (fresh) => {
|
||||
await new Promise((resolve) => {
|
||||
letGo = resolve;
|
||||
});
|
||||
fresh.wallets[0].addresses[0].balance = "7.0";
|
||||
fresh.wallets[0].addresses[0].tokenBalances = [
|
||||
{
|
||||
address: TOKEN_ADDRESS,
|
||||
name: "Test Token",
|
||||
symbol: "TST",
|
||||
decimals: 18,
|
||||
balance: "5.0",
|
||||
holders: null,
|
||||
},
|
||||
];
|
||||
fresh.lastBalanceRefresh = Date.now();
|
||||
});
|
||||
await page.settle();
|
||||
|
||||
const select = page.node("settings-network");
|
||||
select.value = "sepolia";
|
||||
const switching = Promise.all(select.listeners.change.map((fn) => fn()));
|
||||
await page.settle();
|
||||
|
||||
letGo();
|
||||
await refreshSave;
|
||||
await switching;
|
||||
await page.settle();
|
||||
|
||||
expectNothingStored(page);
|
||||
});
|
||||
|
||||
@@ -720,7 +720,6 @@ describe("the popup", () => {
|
||||
tokenRow(TRACKED, "TRK"),
|
||||
tokenRow(UNTRACKED, "TST"),
|
||||
];
|
||||
return [];
|
||||
});
|
||||
const ticking = page.tick();
|
||||
await page.settle();
|
||||
@@ -765,7 +764,6 @@ describe("the popup", () => {
|
||||
addr.tokenBalances = after
|
||||
? [tokenRow(TRACKED, "TRK"), tokenRow(UNTRACKED, "TST")]
|
||||
: [tokenRow(TRACKED, "TRK")];
|
||||
return [];
|
||||
});
|
||||
|
||||
anotherPageSaves(page, { useBlockscout: after });
|
||||
|
||||
@@ -1,81 +0,0 @@
|
||||
// The token screen, the Send screen and the confirmation screen for the
|
||||
// contract at USDC's mainnet address. No address holds it and the user does
|
||||
// not track it, so only the bundled token list can name it.
|
||||
//
|
||||
// The bundled token list holds Ethereum Mainnet contracts, so these screens
|
||||
// name the token from it on Ethereum Mainnet only
|
||||
// (https://git.eeqj.de/sneak/AutistMask/issues/632). Driven through the real
|
||||
// popup over a stored profile.
|
||||
|
||||
const {
|
||||
bootPopup,
|
||||
cleanupPopup,
|
||||
unversionedValidProfile,
|
||||
} = require("./support/popupBoot");
|
||||
|
||||
const USDC = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
|
||||
const RECIPIENT = "0x711e691962E5c054b78071C789A0C8CE657377aD";
|
||||
|
||||
afterEach(() => {
|
||||
cleanupPopup();
|
||||
});
|
||||
|
||||
// The popup reopened onto AddressToken for USDC's address, on `networkId`.
|
||||
function bootOnToken(networkId) {
|
||||
return bootPopup(
|
||||
unversionedValidProfile({
|
||||
networkId,
|
||||
currentView: "address-token",
|
||||
viewStack: ["main", "address"],
|
||||
selectedWallet: 0,
|
||||
selectedAddress: 0,
|
||||
selectedToken: USDC,
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
// AddressToken's Send, then Review for 1 token to RECIPIENT.
|
||||
async function reviewSend(boot) {
|
||||
await boot.click("btn-address-token-send");
|
||||
expect(boot.visibleViews()).toEqual(["send"]);
|
||||
boot.node("send-to").value = RECIPIENT;
|
||||
boot.node("send-amount").value = "1";
|
||||
await boot.click("btn-send-review");
|
||||
expect(boot.visibleViews()).toEqual(["confirm-tx"]);
|
||||
}
|
||||
|
||||
describe("on Ethereum Mainnet, the bundled list names the token", () => {
|
||||
test("on the token screen", async () => {
|
||||
const boot = await bootOnToken("mainnet");
|
||||
expect(boot.visibleViews()).toEqual(["address-token"]);
|
||||
expect(boot.text("address-token-title")).toContain("USDC");
|
||||
const info = boot.node("address-token-contract-info").innerHTML;
|
||||
expect(info).toContain(
|
||||
'<span class="text-muted">Decimals:</span> 6</div>',
|
||||
);
|
||||
});
|
||||
|
||||
test("on the Send screen and the confirmation screen", async () => {
|
||||
const boot = await bootOnToken("mainnet");
|
||||
await reviewSend(boot);
|
||||
expect(boot.text("send-balance")).toContain("USDC");
|
||||
expect(boot.text("confirm-amount")).toContain("USDC");
|
||||
});
|
||||
});
|
||||
|
||||
describe("with Sepolia active, the bundled list does not name the token", () => {
|
||||
test("on the token screen", async () => {
|
||||
const boot = await bootOnToken("sepolia");
|
||||
expect(boot.visibleViews()).toEqual(["address-token"]);
|
||||
expect(boot.text("address-token-title")).not.toContain("USDC");
|
||||
const info = boot.node("address-token-contract-info").innerHTML;
|
||||
expect(info).not.toContain("Decimals:");
|
||||
});
|
||||
|
||||
test("on the Send screen and the confirmation screen", async () => {
|
||||
const boot = await bootOnToken("sepolia");
|
||||
await reviewSend(boot);
|
||||
expect(boot.text("send-balance")).not.toContain("USDC");
|
||||
expect(boot.text("confirm-amount")).not.toContain("USDC");
|
||||
});
|
||||
});
|
||||
@@ -56,18 +56,7 @@ async function settle() {
|
||||
for (let i = 0; i < 50; i++) await Promise.resolve();
|
||||
}
|
||||
|
||||
// While an approval is pending, the background starts a 20-second timer to
|
||||
// keep itself running. The timer is stubbed and never starts, so no test in
|
||||
// this file leaves it running.
|
||||
let keepRunningTimer;
|
||||
beforeEach(() => {
|
||||
keepRunningTimer = jest
|
||||
.spyOn(global, "setInterval")
|
||||
.mockImplementation(() => 1);
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
keepRunningTimer.mockRestore();
|
||||
delete global.chrome;
|
||||
});
|
||||
|
||||
|
||||
@@ -64,18 +64,7 @@ async function settle() {
|
||||
for (let i = 0; i < 50; i++) await Promise.resolve();
|
||||
}
|
||||
|
||||
// While an approval is pending, the background starts a 20-second timer to
|
||||
// keep itself running. The timer is stubbed and never starts, so no test in
|
||||
// this file leaves it running.
|
||||
let keepRunningTimer;
|
||||
beforeEach(() => {
|
||||
keepRunningTimer = jest
|
||||
.spyOn(global, "setInterval")
|
||||
.mockImplementation(() => 1);
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
keepRunningTimer.mockRestore();
|
||||
delete global.chrome;
|
||||
});
|
||||
|
||||
|
||||
@@ -76,18 +76,7 @@ async function settle() {
|
||||
for (let i = 0; i < 60; i++) await Promise.resolve();
|
||||
}
|
||||
|
||||
// While an approval is pending, the background starts a 20-second timer to
|
||||
// keep itself running. The timer is stubbed and never starts, so no test in
|
||||
// this file leaves it running.
|
||||
let keepRunningTimer;
|
||||
beforeEach(() => {
|
||||
keepRunningTimer = jest
|
||||
.spyOn(global, "setInterval")
|
||||
.mockImplementation(() => 1);
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
keepRunningTimer.mockRestore();
|
||||
delete global.chrome;
|
||||
});
|
||||
|
||||
|
||||
@@ -226,7 +226,6 @@ const PRIVATE_KEY = "0x" + "11".repeat(32);
|
||||
const HOLDER = new Wallet(PRIVATE_KEY).address;
|
||||
const RECIPIENT = "0xC0FfEE0000000000000000000000000000c0fFEe";
|
||||
const TOKEN = "0x7070707070707070707070707070707070707070";
|
||||
const USDC = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48";
|
||||
const PASSWORD = "correct horse battery staple";
|
||||
|
||||
function el(id) {
|
||||
@@ -319,7 +318,7 @@ async function switchReopenAndGoBack(reviewedOn, switchedTo) {
|
||||
setBackRenderer(makeBackRenderer(state, { confirmTx }));
|
||||
confirmTx.init({});
|
||||
prices.ETH = 2000;
|
||||
prices[USDC] = 1;
|
||||
prices.USDC = 1;
|
||||
mockNode.asked = [];
|
||||
global.fetch.mockClear();
|
||||
goBack();
|
||||
@@ -642,7 +641,7 @@ describe.each([
|
||||
test("of an ERC-20 token, links the token contract to that network's explorer and prices the token by that network", async () => {
|
||||
mockNode.tokenUnits[reviewedOn] = 50000000n;
|
||||
await review(reviewedOn, {
|
||||
token: USDC,
|
||||
token: TOKEN,
|
||||
tokenSymbol: "USDC",
|
||||
tokenDecimals: 6,
|
||||
amount: "10",
|
||||
@@ -653,7 +652,7 @@ describe.each([
|
||||
"ERC-20 token transfer (USDC)",
|
||||
);
|
||||
expect(el("confirm-token-contract").innerHTML).toContain(
|
||||
`href="${explorerUrl}/address/${USDC}"`,
|
||||
`href="${explorerUrl}/address/${TOKEN}"`,
|
||||
);
|
||||
expect(el("confirm-amount").textContent).toBe(
|
||||
"10.0000 USDC" + usdOn(reviewedOn, "$10.00"),
|
||||
|
||||
@@ -57,18 +57,7 @@ async function settle() {
|
||||
for (let i = 0; i < 50; i++) await Promise.resolve();
|
||||
}
|
||||
|
||||
// While an approval is pending, the background starts a 20-second timer to
|
||||
// keep itself running. The timer is stubbed and never starts, so no test in
|
||||
// this file leaves it running.
|
||||
let keepRunningTimer;
|
||||
beforeEach(() => {
|
||||
keepRunningTimer = jest
|
||||
.spyOn(global, "setInterval")
|
||||
.mockImplementation(() => 1);
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
keepRunningTimer.mockRestore();
|
||||
delete global.chrome;
|
||||
jest.resetModules();
|
||||
});
|
||||
|
||||
@@ -153,7 +153,7 @@ describe("the balance warning on the removal confirmation", () => {
|
||||
|
||||
test("the USD total is shown when prices are known", () => {
|
||||
prices.ETH = 2000;
|
||||
prices[USDC] = 1;
|
||||
prices.USDC = 1;
|
||||
expect(balanceWarningHtml(TOKEN_ONLY)).toContain("Total: $2,500.00");
|
||||
expect(balanceWarningHtml(ETH_ONLY)).toContain("Total: $3,000.00");
|
||||
});
|
||||
|
||||
@@ -102,17 +102,6 @@ function makeDocument() {
|
||||
|
||||
// ------------------------------------------------------------ harness
|
||||
|
||||
// showFlash() starts a timer that clears the message two seconds later. Each
|
||||
// test here runs on fake timers and drops them in afterEach, so that timer
|
||||
// never outlives the test.
|
||||
beforeEach(() => {
|
||||
jest.useFakeTimers();
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
jest.useRealTimers();
|
||||
});
|
||||
|
||||
function wallet(name, secret, addresses) {
|
||||
return {
|
||||
type: "hd",
|
||||
|
||||
+1
-13
@@ -43,15 +43,12 @@ const GAS_PRICE_WEI = BASE_FEE_WEI + PRIORITY_FEE_WEI;
|
||||
|
||||
const STUB_BLOCK_NUMBER = 21000000;
|
||||
|
||||
// A 32-byte zero word, returned for every eth_call but a price feed's
|
||||
// latestRoundData() (see rpcResult() below). It is what makes ethers'
|
||||
// A 32-byte zero word, returned for every eth_call. It is what makes ethers'
|
||||
// ENS reverse lookup resolve to "no resolver set" instead of throwing, and a
|
||||
// throw there reaches the console through src/shared/log.js, which fails the
|
||||
// run on its own.
|
||||
const ZERO_WORD = "0x" + "0".repeat(64);
|
||||
|
||||
const SELECTOR_LATEST_ROUND_DATA = "0xfeaf968c";
|
||||
|
||||
// One ETH, so the popup's balance lines render something and the wallet does
|
||||
// not look empty on the approval screen.
|
||||
const STUB_BALANCE_WEI = 10n ** 18n;
|
||||
@@ -114,15 +111,6 @@ function rpcResult(req, state) {
|
||||
return latestBlock();
|
||||
}
|
||||
|
||||
// A price feed's latestRoundData() gets five zero words, as in network.js:
|
||||
// a price of zero, which the wallet counts as no price.
|
||||
const data = String(
|
||||
(req.params && req.params[0] && req.params[0].data) || "",
|
||||
);
|
||||
if (method === "eth_call" && data.startsWith(SELECTOR_LATEST_ROUND_DATA)) {
|
||||
return "0x" + "0".repeat(64 * 5);
|
||||
}
|
||||
|
||||
if (Object.prototype.hasOwnProperty.call(RPC_RESULTS, method)) {
|
||||
return RPC_RESULTS[method];
|
||||
}
|
||||
|
||||
@@ -251,13 +251,8 @@ const SELECTOR_DECIMALS = "0x313ce567";
|
||||
const SELECTOR_SYMBOL = "0x95d89b41";
|
||||
const SELECTOR_NAME = "0x06fdde03";
|
||||
const SELECTOR_BALANCE_OF = "0x70a08231";
|
||||
const SELECTOR_LATEST_ROUND_DATA = "0xfeaf968c";
|
||||
|
||||
// On any contract, a latestRoundData() call is answered with five zero words.
|
||||
// That is a round with a price of zero, which the wallet counts as no
|
||||
// price. So no screen shows a USD value beside the amounts the tests compare.
|
||||
//
|
||||
// Every other eth_call answers with a zero word except decimals(), symbol(),
|
||||
// Every eth_call still answers with a zero word except decimals(), symbol(),
|
||||
// name() and balanceOf() on the stub token. The wallet reads decimals() back
|
||||
// at signing time to compare with the scale the confirmation screen rendered
|
||||
// (issue #305). Adding the token by its contract address reads the first three
|
||||
@@ -278,9 +273,6 @@ function ethCallResult(req, opts) {
|
||||
if (!call || typeof call !== "object") return ZERO_WORD;
|
||||
const data = String(call.data || call.input || "").toLowerCase();
|
||||
const to = String(call.to || "").toLowerCase();
|
||||
if (data.startsWith(SELECTOR_LATEST_ROUND_DATA)) {
|
||||
return "0x" + "0".repeat(64 * 5);
|
||||
}
|
||||
if (to !== STUB_TOKEN.address) return ZERO_WORD;
|
||||
if (data.startsWith(SELECTOR_DECIMALS)) {
|
||||
return word(opts.tokenDecimalsOverride ?? STUB_TOKEN.decimals);
|
||||
@@ -772,6 +764,11 @@ async function installNetworkStubs(ctx, opts) {
|
||||
}
|
||||
}
|
||||
|
||||
// CoinDesk price tick
|
||||
if (url.hostname.endsWith("coindesk.com")) {
|
||||
return jsonResponse(route, { Data: {} });
|
||||
}
|
||||
|
||||
// The interception canary's own request. Answered with nothing: what
|
||||
// is being observed is that it arrived here at all.
|
||||
if (url.href === WORKER_PROBE_URL) {
|
||||
|
||||
+1
-2
@@ -969,8 +969,7 @@ test("a token added by its contract address is listed on the address screen (#15
|
||||
await visible(env.page, "#view-address");
|
||||
|
||||
// No wait: the confirm renders the balance list before it shows the
|
||||
// screen. The refresh it starts draws the list again, with the row still
|
||||
// in it.
|
||||
// screen, and nothing renders the list again while the screen is up.
|
||||
const row = env.page.locator(
|
||||
'#address-balances [data-token="' + STUB_TOKEN.address + '"]',
|
||||
{ hasText: STUB_TOKEN.symbol },
|
||||
|
||||
@@ -111,15 +111,13 @@ function respondWith(items) {
|
||||
}
|
||||
|
||||
// Fetch and place the result exactly where refreshBalances() places it, so the
|
||||
// approval screens read what a real refresh on Ethereum Mainnet would have
|
||||
// left on state.
|
||||
// approval screens read what a real refresh would have left on state.
|
||||
async function fetchOnto(items, trackedTokens = []) {
|
||||
respondWith(items);
|
||||
const balances = await fetchTokenBalances(
|
||||
HOLDER,
|
||||
BLOCKSCOUT,
|
||||
trackedTokens,
|
||||
"0x1",
|
||||
);
|
||||
state.trackedTokens = trackedTokens;
|
||||
state.wallets = [
|
||||
|
||||
@@ -48,7 +48,6 @@ async function boot(stored) {
|
||||
for (const wallet of wallets) {
|
||||
for (const addr of wallet.addresses) addr.balance = chainBalance;
|
||||
}
|
||||
return [];
|
||||
});
|
||||
return { page, refreshBalances };
|
||||
}
|
||||
|
||||
@@ -88,7 +88,6 @@ describe.each([
|
||||
showFlash: (msg) => flashes.push(msg),
|
||||
escapeHtml: (s) => s,
|
||||
goBack: () => {},
|
||||
trackToken: () => {},
|
||||
}));
|
||||
|
||||
require("../src/popup/views/" + view).init({
|
||||
|
||||
@@ -1,500 +0,0 @@
|
||||
// Home, AddressDetail and AddressToken drop a transaction history answer that
|
||||
// lands after a network switch. A dropped answer draws no rows and saves no
|
||||
// fraud contracts (https://git.eeqj.de/sneak/AutistMask/issues/657).
|
||||
//
|
||||
// Most tests hold the history request open, switch the network or what the
|
||||
// screen shows, and then let the answer land. The views run against a minimal
|
||||
// DOM stub, as in tests/transactionListCancelled.test.js, and over
|
||||
// tests/support/storageStub.js.
|
||||
|
||||
const { makeStorageStub } = require("./support/storageStub");
|
||||
const { STATE_SCHEMA_VERSION } = require("../src/shared/stateSchema");
|
||||
|
||||
jest.mock("../src/shared/transactions", () => ({
|
||||
...jest.requireActual("../src/shared/transactions"),
|
||||
fetchRecentTransactions: jest.fn(async () => []),
|
||||
}));
|
||||
jest.mock("../src/shared/ens", () => ({
|
||||
resolveEnsNames: jest.fn(async () => new Map()),
|
||||
}));
|
||||
|
||||
const { fetchRecentTransactions } = require("../src/shared/transactions");
|
||||
const { resolveEnsNames } = require("../src/shared/ens");
|
||||
const { state, loadState } = require("../src/shared/state");
|
||||
const { onChainSwitch } = require("../src/shared/chainSwitch");
|
||||
const { applyChainSwitchFields } = require("../src/shared/chainSwitchFields");
|
||||
const { storedNetworkIs } = require("../src/shared/storedSettings");
|
||||
const home = require("../src/popup/views/home");
|
||||
const addressDetail = require("../src/popup/views/addressDetail");
|
||||
const addressToken = require("../src/popup/views/addressToken");
|
||||
|
||||
const ADDRESS = "0x1111111111111111111111111111111111111111";
|
||||
const OTHER_ADDRESS = "0x2222222222222222222222222222222222222222";
|
||||
const RECIPIENT = "0x66133E8ea0f5D1d612D2502a968757D1048c214a";
|
||||
// A contract that sends a token claiming USDT's symbol. Spotting the spoof
|
||||
// adds this contract to the fraud contracts.
|
||||
const SPOOF_CONTRACT = "0x3333333333333333333333333333333333333333";
|
||||
const TOKEN = "0x6B175474E89094C44Da98b954EedeAC495271d0F";
|
||||
|
||||
// A profile on Ethereum Mainnet with two addresses, "Use Blockscout" on and no
|
||||
// fraud contracts.
|
||||
function profile() {
|
||||
return {
|
||||
schemaVersion: STATE_SCHEMA_VERSION,
|
||||
hasWallet: true,
|
||||
wallets: [
|
||||
{
|
||||
type: "hd",
|
||||
name: "Main",
|
||||
xpub: "xpub-main",
|
||||
encryptedSecret: "encrypted-secret",
|
||||
nextIndex: 2,
|
||||
addresses: [
|
||||
{ address: ADDRESS, balance: "1.0", tokenBalances: [] },
|
||||
{
|
||||
address: OTHER_ADDRESS,
|
||||
balance: "0.0",
|
||||
tokenBalances: [],
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
activeAddress: ADDRESS,
|
||||
networkId: "mainnet",
|
||||
rpcUrl: "https://ethereum-rpc.publicnode.com",
|
||||
blockscoutUrl: "https://eth.blockscout.com/api/v2",
|
||||
useBlockscout: true,
|
||||
fraudContracts: [],
|
||||
};
|
||||
}
|
||||
|
||||
// What Blockscout answers for ADDRESS on Ethereum Mainnet:
|
||||
//
|
||||
// - a transfer of ETH from ADDRESS;
|
||||
// - a transfer of the fake USDT from SPOOF_CONTRACT.
|
||||
function history() {
|
||||
return [
|
||||
{
|
||||
hash: "0x85215772ed26ea8b39c2b3b18779030487efbe0b5fd7e882592b2f62b837be84",
|
||||
blockNumber: 2,
|
||||
from: ADDRESS,
|
||||
to: RECIPIENT,
|
||||
value: "1.0000",
|
||||
exactValue: "1.0",
|
||||
rawAmount: "1000000000000000000",
|
||||
rawUnit: "wei",
|
||||
symbol: "ETH",
|
||||
timestamp: 1790000000,
|
||||
isError: false,
|
||||
directionLabel: "Sent",
|
||||
direction: "sent",
|
||||
contractAddress: null,
|
||||
chainId: "0x1",
|
||||
},
|
||||
{
|
||||
hash: "0x0d6a6e0a0d1b7d4c3b2a19087f6e5d4c3b2a19087f6e5d4c3b2a19087f6e5d4c",
|
||||
blockNumber: 1,
|
||||
from: SPOOF_CONTRACT,
|
||||
to: ADDRESS,
|
||||
value: "100.0000",
|
||||
exactValue: "100.0",
|
||||
rawAmount: "100000000",
|
||||
rawUnit: "base units",
|
||||
symbol: "USDT",
|
||||
timestamp: 1790000000,
|
||||
isError: false,
|
||||
directionLabel: "Received",
|
||||
direction: "received",
|
||||
contractAddress: SPOOF_CONTRACT,
|
||||
chainId: "0x1",
|
||||
},
|
||||
];
|
||||
}
|
||||
|
||||
// The next history request waits until the returned function is called, and
|
||||
// then answers with `answer`.
|
||||
function holdHistory(answer = history()) {
|
||||
let land;
|
||||
fetchRecentTransactions.mockImplementationOnce(
|
||||
() =>
|
||||
new Promise((resolve) => {
|
||||
land = () => resolve(answer);
|
||||
}),
|
||||
);
|
||||
return () => land();
|
||||
}
|
||||
|
||||
// The next history request waits until the returned function is called, and
|
||||
// then fails.
|
||||
function holdFailure() {
|
||||
let fail;
|
||||
fetchRecentTransactions.mockImplementationOnce(
|
||||
() =>
|
||||
new Promise((resolve, reject) => {
|
||||
fail = () => reject(new Error("Blockscout is down"));
|
||||
}),
|
||||
);
|
||||
return () => fail();
|
||||
}
|
||||
|
||||
// Another write holds the lock until the returned function is called. Every
|
||||
// save waits until then.
|
||||
function holdLock() {
|
||||
let release;
|
||||
const held = navigator.locks.request(
|
||||
"autistmask",
|
||||
() =>
|
||||
new Promise((resolve) => {
|
||||
release = resolve;
|
||||
}),
|
||||
);
|
||||
return async () => {
|
||||
release();
|
||||
await held;
|
||||
};
|
||||
}
|
||||
|
||||
function makeElement(id) {
|
||||
const el = {
|
||||
id,
|
||||
textContent: "",
|
||||
value: "",
|
||||
innerHTML: "",
|
||||
style: {},
|
||||
dataset: {},
|
||||
classList: {
|
||||
add: () => {},
|
||||
remove: () => {},
|
||||
contains: () => false,
|
||||
toggle: () => false,
|
||||
},
|
||||
addEventListener: () => {},
|
||||
querySelectorAll: () => [],
|
||||
appendChild: () => {},
|
||||
};
|
||||
// Views reach for .parentElement to hide whole sections.
|
||||
Object.defineProperty(el, "parentElement", {
|
||||
get: () => node(id + "-parent"),
|
||||
});
|
||||
return el;
|
||||
}
|
||||
|
||||
function makeDocument() {
|
||||
const els = new Map();
|
||||
return {
|
||||
getElementById(id) {
|
||||
// The debug banner is created on demand by helpers.js; absent
|
||||
// is the state a non-debug, non-testnet popup is in.
|
||||
if (id === "debug-banner") return null;
|
||||
if (!els.has(id)) els.set(id, makeElement(id));
|
||||
return els.get(id);
|
||||
},
|
||||
createElement: () => makeElement("created"),
|
||||
addEventListener: () => {},
|
||||
body: { prepend: () => {} },
|
||||
};
|
||||
}
|
||||
|
||||
function node(id) {
|
||||
return globalThis.document.getElementById(id);
|
||||
}
|
||||
|
||||
// Lets every promise that is not held open settle.
|
||||
function settle() {
|
||||
return new Promise((resolve) => setTimeout(resolve, 0));
|
||||
}
|
||||
|
||||
let storage;
|
||||
|
||||
beforeEach(async () => {
|
||||
storage = makeStorageStub({ autistmask: profile() });
|
||||
globalThis.chrome = {
|
||||
storage: { local: storage.local, onChanged: storage.onChanged },
|
||||
};
|
||||
globalThis.document = makeDocument();
|
||||
globalThis.window = { location: { search: "" } };
|
||||
await loadState();
|
||||
state.viewStack = [];
|
||||
state.selectedWallet = 0;
|
||||
state.selectedAddress = 0;
|
||||
state.selectedToken = "ETH";
|
||||
const ctx = { pageClosed: new AbortController().signal };
|
||||
addressDetail.init(ctx);
|
||||
addressToken.init(ctx);
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
delete globalThis.chrome;
|
||||
delete globalThis.document;
|
||||
delete globalThis.window;
|
||||
});
|
||||
|
||||
const HOME = {
|
||||
name: "Home",
|
||||
listId: "home-tx-list",
|
||||
open: () => home.render({ pageClosed: new AbortController().signal }),
|
||||
};
|
||||
const ADDRESS_DETAIL = {
|
||||
name: "AddressDetail",
|
||||
listId: "tx-list",
|
||||
open: () => addressDetail.show(),
|
||||
};
|
||||
const ADDRESS_TOKEN = {
|
||||
name: "AddressToken",
|
||||
listId: "address-token-tx-list",
|
||||
open: () => addressToken.show(),
|
||||
};
|
||||
|
||||
// Three ways a test switches the network:
|
||||
//
|
||||
// - made in Settings: the page and storage have both switched;
|
||||
// - saved elsewhere: storage has switched and the page has not;
|
||||
// - not yet stored: the page has switched and storage has not.
|
||||
const SWITCHES = [
|
||||
{
|
||||
how: "made in Settings",
|
||||
to: (networkId) => onChainSwitch(networkId),
|
||||
},
|
||||
{
|
||||
// Another page or the background stored the switch, and this page has
|
||||
// not followed it yet.
|
||||
how: "saved elsewhere",
|
||||
to: async (networkId) => {
|
||||
const record = storage.read("autistmask");
|
||||
applyChainSwitchFields(record, networkId);
|
||||
storage.write("autistmask", record);
|
||||
},
|
||||
},
|
||||
{
|
||||
// The switch's own save has changed the page and has not yet written
|
||||
// storage.
|
||||
how: "not yet stored",
|
||||
to: async (networkId) => {
|
||||
applyChainSwitchFields(state, networkId);
|
||||
},
|
||||
},
|
||||
];
|
||||
|
||||
// The list still shows `before`, and neither the page nor storage holds a
|
||||
// fraud contract.
|
||||
function expectNothingAdded(screen, before) {
|
||||
expect(node(screen.listId).innerHTML).toBe(before);
|
||||
expect(state.fraudContracts).toEqual([]);
|
||||
expect(storage.read("autistmask").fraudContracts).toEqual([]);
|
||||
}
|
||||
|
||||
describe.each([HOME, ADDRESS_DETAIL, ADDRESS_TOKEN])("$name", (screen) => {
|
||||
test("an answer that lands on the same network is drawn and saved", async () => {
|
||||
const land = holdHistory();
|
||||
screen.open();
|
||||
land();
|
||||
await settle();
|
||||
|
||||
expect(node(screen.listId).innerHTML).toContain("tx-row");
|
||||
expect(state.fraudContracts).toEqual([SPOOF_CONTRACT]);
|
||||
expect(storage.read("autistmask").fraudContracts).toEqual([
|
||||
SPOOF_CONTRACT,
|
||||
]);
|
||||
});
|
||||
|
||||
test.each(SWITCHES)(
|
||||
"an answer that lands after a switch $how adds nothing",
|
||||
async ({ to }) => {
|
||||
const land = holdHistory();
|
||||
screen.open();
|
||||
await settle();
|
||||
const before = node(screen.listId).innerHTML;
|
||||
await to("sepolia");
|
||||
land();
|
||||
await settle();
|
||||
|
||||
expectNothingAdded(screen, before);
|
||||
},
|
||||
);
|
||||
|
||||
// The answer is the transfer of ETH alone, which adds no fraud contract.
|
||||
// Nothing is saved, so only the check before the save can drop the answer.
|
||||
test.each(SWITCHES)(
|
||||
"an answer without a fraud contract that lands after a switch $how adds nothing",
|
||||
async ({ to }) => {
|
||||
const land = holdHistory(history().slice(0, 1));
|
||||
screen.open();
|
||||
await settle();
|
||||
const before = node(screen.listId).innerHTML;
|
||||
await to("sepolia");
|
||||
land();
|
||||
await settle();
|
||||
|
||||
expectNothingAdded(screen, before);
|
||||
},
|
||||
);
|
||||
|
||||
test.each(SWITCHES)(
|
||||
"a request that fails after a switch $how shows no message",
|
||||
async ({ to }) => {
|
||||
const fail = holdFailure();
|
||||
screen.open();
|
||||
await settle();
|
||||
const before = node(screen.listId).innerHTML;
|
||||
await to("sepolia");
|
||||
fail();
|
||||
await settle();
|
||||
|
||||
expect(node(screen.listId).innerHTML).toBe(before);
|
||||
},
|
||||
);
|
||||
|
||||
// The user picks Sepolia in Settings while another write holds the lock.
|
||||
// The answer lands, and its save waits behind the switch.
|
||||
test("an answer whose save waits behind a switch made in Settings adds nothing", async () => {
|
||||
const land = holdHistory();
|
||||
screen.open();
|
||||
const before = node(screen.listId).innerHTML;
|
||||
const releaseLock = holdLock();
|
||||
const switching = onChainSwitch("sepolia");
|
||||
land();
|
||||
await settle();
|
||||
await releaseLock();
|
||||
await switching;
|
||||
await settle();
|
||||
|
||||
expectNothingAdded(screen, before);
|
||||
});
|
||||
|
||||
// The answer lands and its save waits for the lock. Another page or the
|
||||
// background then stores a switch.
|
||||
test("an answer whose save waits while a switch is saved elsewhere adds nothing", async () => {
|
||||
const land = holdHistory();
|
||||
screen.open();
|
||||
const before = node(screen.listId).innerHTML;
|
||||
const releaseLock = holdLock();
|
||||
land();
|
||||
await settle();
|
||||
const record = storage.read("autistmask");
|
||||
applyChainSwitchFields(record, "sepolia");
|
||||
storage.write("autistmask", record);
|
||||
await releaseLock();
|
||||
await settle();
|
||||
|
||||
expectNothingAdded(screen, before);
|
||||
});
|
||||
|
||||
// The answer lands and its save waits for the lock. The page then switches,
|
||||
// and storage has not.
|
||||
test("an answer whose save waits while the page switches adds nothing", async () => {
|
||||
const land = holdHistory();
|
||||
screen.open();
|
||||
const before = node(screen.listId).innerHTML;
|
||||
const releaseLock = holdLock();
|
||||
land();
|
||||
await settle();
|
||||
applyChainSwitchFields(state, "sepolia");
|
||||
await releaseLock();
|
||||
await settle();
|
||||
|
||||
expectNothingAdded(screen, before);
|
||||
});
|
||||
|
||||
test("a request that fails after a switch leaves the new network's rows", async () => {
|
||||
const fail = holdFailure();
|
||||
screen.open();
|
||||
await onChainSwitch("sepolia");
|
||||
fetchRecentTransactions.mockImplementationOnce(async () => history());
|
||||
screen.open();
|
||||
await settle();
|
||||
const drawn = node(screen.listId).innerHTML;
|
||||
fail();
|
||||
await settle();
|
||||
|
||||
expect(drawn).toContain("tx-row");
|
||||
expect(node(screen.listId).innerHTML).toBe(drawn);
|
||||
});
|
||||
});
|
||||
|
||||
describe.each([ADDRESS_DETAIL, ADDRESS_TOKEN])("$name", (screen) => {
|
||||
test("an answer that lands once the screen shows another address adds nothing", async () => {
|
||||
const land = holdHistory();
|
||||
screen.open();
|
||||
state.selectedAddress = 1;
|
||||
screen.open();
|
||||
await settle();
|
||||
const before = node(screen.listId).innerHTML;
|
||||
land();
|
||||
await settle();
|
||||
|
||||
expectNothingAdded(screen, before);
|
||||
});
|
||||
|
||||
test("a request that fails once the screen shows another address shows no message", async () => {
|
||||
const fail = holdFailure();
|
||||
screen.open();
|
||||
state.selectedAddress = 1;
|
||||
screen.open();
|
||||
await settle();
|
||||
const before = node(screen.listId).innerHTML;
|
||||
fail();
|
||||
await settle();
|
||||
|
||||
expect(node(screen.listId).innerHTML).toBe(before);
|
||||
});
|
||||
|
||||
// The answer is the transfer of ETH alone, which adds no fraud contract.
|
||||
// Nothing is saved, so only the check after the name lookup can drop the
|
||||
// answer.
|
||||
test("an answer whose name lookup lands after a switch adds nothing", async () => {
|
||||
let landNames;
|
||||
resolveEnsNames.mockImplementationOnce(
|
||||
() =>
|
||||
new Promise((resolve) => {
|
||||
landNames = () => resolve(new Map());
|
||||
}),
|
||||
);
|
||||
fetchRecentTransactions.mockImplementationOnce(async () =>
|
||||
history().slice(0, 1),
|
||||
);
|
||||
screen.open();
|
||||
await settle();
|
||||
const before = node(screen.listId).innerHTML;
|
||||
await onChainSwitch("sepolia");
|
||||
landNames();
|
||||
await settle();
|
||||
|
||||
expectNothingAdded(screen, before);
|
||||
});
|
||||
});
|
||||
|
||||
test("AddressToken: an answer that lands once the screen shows another token adds nothing", async () => {
|
||||
const land = holdHistory();
|
||||
addressToken.show();
|
||||
state.selectedToken = TOKEN;
|
||||
addressToken.show();
|
||||
await settle();
|
||||
const before = node(ADDRESS_TOKEN.listId).innerHTML;
|
||||
land();
|
||||
await settle();
|
||||
|
||||
expectNothingAdded(ADDRESS_TOKEN, before);
|
||||
});
|
||||
|
||||
test("AddressToken: a request that fails once the screen shows another token shows no message", async () => {
|
||||
const fail = holdFailure();
|
||||
addressToken.show();
|
||||
state.selectedToken = TOKEN;
|
||||
addressToken.show();
|
||||
await settle();
|
||||
const before = node(ADDRESS_TOKEN.listId).innerHTML;
|
||||
fail();
|
||||
await settle();
|
||||
|
||||
expect(node(ADDRESS_TOKEN.listId).innerHTML).toBe(before);
|
||||
});
|
||||
|
||||
test("storedNetworkIs(): a failed read counts as no", async () => {
|
||||
globalThis.chrome.storage.local = {
|
||||
get: async () => {
|
||||
throw new Error("storage is down");
|
||||
},
|
||||
};
|
||||
|
||||
await expect(storedNetworkIs("mainnet")).resolves.toBe(false);
|
||||
});
|
||||
@@ -192,13 +192,7 @@ describe("the balance-list spam gate", () => {
|
||||
},
|
||||
}),
|
||||
]);
|
||||
// On Ethereum Mainnet, the only network the known-token list covers.
|
||||
const balances = await fetchTokenBalances(
|
||||
HOLDER,
|
||||
BLOCKSCOUT,
|
||||
[],
|
||||
"0x1",
|
||||
);
|
||||
const balances = await fetchTokenBalances(HOLDER, BLOCKSCOUT, []);
|
||||
expect(balances).toHaveLength(1);
|
||||
expect(balances[0].holders).toBeNull();
|
||||
});
|
||||
|
||||
@@ -253,271 +253,6 @@ test("a switch back in Settings after a follow whose write failed is stored", as
|
||||
expect(told.at(-1).chainId).toBe(NETWORKS.mainnet.chainId);
|
||||
});
|
||||
|
||||
// The user saves an endpoint URL in Settings on Ethereum Mainnet. Before the
|
||||
// URL is stored, the background saves a switch to Sepolia. Another write holds
|
||||
// the lock, so the popup's follow of that switch and the URL's save both wait
|
||||
// for the lock. Either may take it first. The URL is stored for neither
|
||||
// network. The flash message says that the network changed.
|
||||
test.each([
|
||||
{ button: "btn-save-rpc", field: "settings-rpc", first: "follow" },
|
||||
{ button: "btn-save-rpc", field: "settings-rpc", first: "save" },
|
||||
{
|
||||
button: "btn-save-blockscout",
|
||||
field: "settings-blockscout",
|
||||
first: "follow",
|
||||
},
|
||||
{
|
||||
button: "btn-save-blockscout",
|
||||
field: "settings-blockscout",
|
||||
first: "save",
|
||||
},
|
||||
])(
|
||||
"$button saves nothing when the network changes before the URL is stored ($first first)",
|
||||
async ({ button, field, first }) => {
|
||||
const page = await bootOnAddress();
|
||||
await page.click("btn-settings");
|
||||
// This answer passes both endpoint checks. The RPC check reads
|
||||
// Ethereum Mainnet's chain id from it. The Blockscout check reads `ok`.
|
||||
globalThis.fetch.mockResolvedValue({
|
||||
ok: true,
|
||||
json: async () => ({ result: NETWORKS.mainnet.chainId }),
|
||||
});
|
||||
const url = "https://own-node.example.invalid";
|
||||
|
||||
let releaseLock;
|
||||
const lockHeld = navigator.locks.request(
|
||||
"autistmask",
|
||||
() =>
|
||||
new Promise((resolve) => {
|
||||
releaseLock = resolve;
|
||||
}),
|
||||
);
|
||||
// The click handler runs until its save waits for the lock.
|
||||
const tapSave = async () => {
|
||||
page.node(field).value = url;
|
||||
const saving = page.node(button).listeners.click.map((fn) => fn());
|
||||
await page.settle();
|
||||
return saving;
|
||||
};
|
||||
let saving;
|
||||
if (first === "save") saving = await tapSave();
|
||||
await backgroundSwitch(page, "sepolia");
|
||||
if (first === "follow") saving = await tapSave();
|
||||
releaseLock();
|
||||
await lockHeld;
|
||||
await Promise.all(saving);
|
||||
await page.settle();
|
||||
|
||||
const { state } = require("../src/shared/state");
|
||||
expect(state.networkId).toBe("sepolia");
|
||||
expect(JSON.stringify(page.storage.read("autistmask"))).not.toContain(
|
||||
url,
|
||||
);
|
||||
expect(page.text("flash-msg")).toBe(
|
||||
"The URL was not saved because the network changed.",
|
||||
);
|
||||
},
|
||||
);
|
||||
|
||||
// The popup's follow of the background's switch to Sepolia has set `state` to
|
||||
// Sepolia. The follow's write has not returned yet, so Settings still shows
|
||||
// Ethereum Mainnet. The user taps "Save" there. The URL is for Ethereum
|
||||
// Mainnet, so the save stores the URL for neither network.
|
||||
test.each([
|
||||
{ button: "btn-save-rpc", field: "settings-rpc" },
|
||||
{ button: "btn-save-blockscout", field: "settings-blockscout" },
|
||||
])(
|
||||
"$button saves nothing when tapped while the follow's write waits",
|
||||
async ({ button, field }) => {
|
||||
const page = await bootOnAddress();
|
||||
await page.click("btn-settings");
|
||||
// This answer passes both endpoint checks on Ethereum Mainnet.
|
||||
globalThis.fetch.mockResolvedValue({
|
||||
ok: true,
|
||||
json: async () => ({ result: NETWORKS.mainnet.chainId }),
|
||||
});
|
||||
const url = "https://own-node.example.invalid";
|
||||
|
||||
const { set } = page.storage.local;
|
||||
const write = set.getMockImplementation();
|
||||
let releaseWrite;
|
||||
const writeHeld = new Promise((resolve) => {
|
||||
releaseWrite = resolve;
|
||||
});
|
||||
// The background's write lands; the next, the follow's, waits.
|
||||
set.mockImplementationOnce(write).mockImplementationOnce(
|
||||
async (items) => {
|
||||
await writeHeld;
|
||||
await write(items);
|
||||
},
|
||||
);
|
||||
await backgroundSwitch(page, "sepolia");
|
||||
const { state } = require("../src/shared/state");
|
||||
expect(state.networkId).toBe("sepolia");
|
||||
expect(page.value("settings-network")).toBe("mainnet");
|
||||
|
||||
page.node(field).value = url;
|
||||
const saving = page.node(button).listeners.click.map((fn) => fn());
|
||||
await page.settle();
|
||||
releaseWrite();
|
||||
await Promise.all(saving);
|
||||
await page.settle();
|
||||
|
||||
expect(JSON.stringify(page.storage.read("autistmask"))).not.toContain(
|
||||
url,
|
||||
);
|
||||
expect(page.text("flash-msg")).toBe(
|
||||
"The URL was not saved because the network changed.",
|
||||
);
|
||||
},
|
||||
);
|
||||
|
||||
// The user taps the RPC "Save" on Ethereum Mainnet. While the check waits for
|
||||
// the node's answer, the popup follows the background's switch to Sepolia. The
|
||||
// node answers with Sepolia's chain id. So the check refuses the node for
|
||||
// Ethereum Mainnet, and nothing is stored.
|
||||
test("the RPC check compares the answer with the network at the tap", async () => {
|
||||
const page = await bootOnAddress();
|
||||
await page.click("btn-settings");
|
||||
let answer;
|
||||
globalThis.fetch.mockReturnValue(
|
||||
new Promise((resolve) => {
|
||||
answer = resolve;
|
||||
}),
|
||||
);
|
||||
const url = "https://sepolia-node.example.invalid";
|
||||
|
||||
page.node("settings-rpc").value = url;
|
||||
const saving = page.node("btn-save-rpc").listeners.click.map((fn) => fn());
|
||||
await page.settle();
|
||||
await backgroundSwitch(page, "sepolia");
|
||||
const { state } = require("../src/shared/state");
|
||||
expect(state.networkId).toBe("sepolia");
|
||||
answer({ json: async () => ({ result: NETWORKS.sepolia.chainId }) });
|
||||
await Promise.all(saving);
|
||||
await page.settle();
|
||||
|
||||
expect(JSON.stringify(page.storage.read("autistmask"))).not.toContain(url);
|
||||
expect(page.text("flash-msg")).toBe(
|
||||
"Wrong network: expected Ethereum Mainnet.",
|
||||
);
|
||||
});
|
||||
|
||||
// The user taps the Blockscout "Save" on Ethereum Mainnet. While the check
|
||||
// waits for Blockscout's answer, the popup follows the background's switch to
|
||||
// Sepolia. The URL is for Ethereum Mainnet, so nothing is stored.
|
||||
test("the Blockscout save is for the network at the tap", async () => {
|
||||
const page = await bootOnAddress();
|
||||
await page.click("btn-settings");
|
||||
let answer;
|
||||
globalThis.fetch.mockReturnValue(
|
||||
new Promise((resolve) => {
|
||||
answer = resolve;
|
||||
}),
|
||||
);
|
||||
const url = "https://own-explorer.example.invalid/api/v2";
|
||||
|
||||
page.node("settings-blockscout").value = url;
|
||||
const saving = page
|
||||
.node("btn-save-blockscout")
|
||||
.listeners.click.map((fn) => fn());
|
||||
await page.settle();
|
||||
await backgroundSwitch(page, "sepolia");
|
||||
expect(page.value("settings-network")).toBe("sepolia");
|
||||
answer({ ok: true });
|
||||
await Promise.all(saving);
|
||||
await page.settle();
|
||||
|
||||
expect(JSON.stringify(page.storage.read("autistmask"))).not.toContain(url);
|
||||
expect(page.text("flash-msg")).toBe(
|
||||
"The URL was not saved because the network changed.",
|
||||
);
|
||||
});
|
||||
|
||||
// Settings is open when the network changes to Sepolia. The popup follows the
|
||||
// background's switch, or the user picks Sepolia in the network selector. Each
|
||||
// "Save" after the switch stores its URL for Sepolia.
|
||||
test.each([
|
||||
["a follow", (page) => backgroundSwitch(page, "sepolia")],
|
||||
[
|
||||
"the network selector",
|
||||
async (page) => {
|
||||
const select = page.node("settings-network");
|
||||
select.value = "sepolia";
|
||||
for (const fn of select.listeners.change) await fn();
|
||||
await page.settle();
|
||||
},
|
||||
],
|
||||
])(
|
||||
"after a switch to Sepolia by %s, Settings saves each URL for Sepolia",
|
||||
async (_how, switchToSepolia) => {
|
||||
const page = await bootOnAddress();
|
||||
await page.click("btn-settings");
|
||||
await switchToSepolia(page);
|
||||
// This answer passes both endpoint checks on Sepolia. The RPC check
|
||||
// reads Sepolia's chain id from it. The Blockscout check reads `ok`.
|
||||
globalThis.fetch.mockResolvedValue({
|
||||
ok: true,
|
||||
json: async () => ({ result: NETWORKS.sepolia.chainId }),
|
||||
});
|
||||
const rpcUrl = "https://own-node.example.invalid";
|
||||
const blockscoutUrl = "https://own-explorer.example.invalid/api/v2";
|
||||
|
||||
page.node("settings-rpc").value = rpcUrl;
|
||||
await page.click("btn-save-rpc");
|
||||
expect(page.text("flash-msg")).toBe("Saved.");
|
||||
page.node("settings-blockscout").value = blockscoutUrl;
|
||||
await page.click("btn-save-blockscout");
|
||||
expect(page.text("flash-msg")).toBe("Saved.");
|
||||
|
||||
const stored = page.storage.read("autistmask");
|
||||
expect(stored.networkId).toBe("sepolia");
|
||||
expect(stored.rpcUrl).toBe(rpcUrl);
|
||||
expect(stored.blockscoutUrl).toBe(blockscoutUrl);
|
||||
},
|
||||
);
|
||||
|
||||
// The user picks Sepolia in Settings, but the switch's write fails. The page is
|
||||
// then on Sepolia, while Settings was last drawn for Ethereum Mainnet. A "Save"
|
||||
// after the failed switch stores nothing for either network.
|
||||
test.each([
|
||||
{ button: "btn-save-rpc", field: "settings-rpc" },
|
||||
{ button: "btn-save-blockscout", field: "settings-blockscout" },
|
||||
])(
|
||||
"$button saves nothing after a switch in Settings whose write failed",
|
||||
async ({ button, field }) => {
|
||||
const page = await bootOnAddress();
|
||||
await page.click("btn-settings");
|
||||
page.storage.local.set.mockRejectedValueOnce(
|
||||
new Error("quota exceeded"),
|
||||
);
|
||||
const select = page.node("settings-network");
|
||||
select.value = "sepolia";
|
||||
for (const fn of select.listeners.change) {
|
||||
await expect(fn()).rejects.toThrow("quota exceeded");
|
||||
}
|
||||
await page.settle();
|
||||
const { state } = require("../src/shared/state");
|
||||
expect(state.networkId).toBe("sepolia");
|
||||
// This answer passes both endpoint checks on Ethereum Mainnet.
|
||||
globalThis.fetch.mockResolvedValue({
|
||||
ok: true,
|
||||
json: async () => ({ result: NETWORKS.mainnet.chainId }),
|
||||
});
|
||||
const url = "https://own-node.example.invalid";
|
||||
|
||||
page.node(field).value = url;
|
||||
await page.click(button);
|
||||
|
||||
expect(JSON.stringify(page.storage.read("autistmask"))).not.toContain(
|
||||
url,
|
||||
);
|
||||
expect(page.text("flash-msg")).toBe(
|
||||
"The URL was not saved because the network changed.",
|
||||
);
|
||||
},
|
||||
);
|
||||
|
||||
// Such as one a newer build wrote, which this build cannot read. Nothing reads
|
||||
// or writes the stored record for it: the popup's next save finds it, as
|
||||
// before.
|
||||
|
||||
@@ -1,272 +0,0 @@
|
||||
// USD prices are read from Chainlink price feeds on mainnet, through the RPC
|
||||
// endpoint (https://git.eeqj.de/sneak/AutistMask/issues/525).
|
||||
//
|
||||
// The real refreshPrices() runs against a fake JSON-RPC node, answered through
|
||||
// ethers' own request hook. The hook also records the body of every HTTP
|
||||
// request, so a test can count them.
|
||||
|
||||
// prices.js pulls in state.js, which reads chrome.storage.local at load.
|
||||
globalThis.chrome = {
|
||||
storage: { local: { get: async () => ({}), set: async () => {} } },
|
||||
};
|
||||
|
||||
const { AbiCoder, FetchRequest } = require("ethers");
|
||||
const {
|
||||
prices,
|
||||
refreshPrices,
|
||||
clearPrices,
|
||||
getPrice,
|
||||
getAddressValue,
|
||||
} = require("../src/shared/prices");
|
||||
const { state } = require("../src/shared/state");
|
||||
const {
|
||||
TOKENS,
|
||||
ETH_USD_FEED,
|
||||
USD_PRICE_FEEDS,
|
||||
PRICE_FEED_BY_ADDRESS,
|
||||
} = require("../src/shared/tokenList");
|
||||
|
||||
const RPC_URL = "https://rpc.example.invalid";
|
||||
const NOW = Date.UTC(2026, 9, 27, 12, 0, 0);
|
||||
const NOW_SECONDS = NOW / 1000;
|
||||
|
||||
const USDC = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48";
|
||||
const LINK = "0x514910771af9ca656af840dff83e8264ecf986ca";
|
||||
const DAI = "0x6b175474e89094c44da98b954eedeac495271d0f";
|
||||
// A token at an address of its own that calls itself USDC.
|
||||
const FAKE_USDC = "0x9999999999999999999999999999999999999999";
|
||||
|
||||
const ETH_FEED = ETH_USD_FEED.address.toLowerCase();
|
||||
const USDC_FEED = PRICE_FEED_BY_ADDRESS.get(USDC).address.toLowerCase();
|
||||
const LINK_FEED = PRICE_FEED_BY_ADDRESS.get(LINK).address.toLowerCase();
|
||||
const DAI_FEED = PRICE_FEED_BY_ADDRESS.get(DAI).address.toLowerCase();
|
||||
|
||||
// What each feed answers, by its lowercased address: the price in the feed's
|
||||
// own units and the time it was written. A feed that is not here makes the
|
||||
// call fail.
|
||||
let rounds;
|
||||
// The parsed body of every HTTP request the node received.
|
||||
let requests;
|
||||
let logged;
|
||||
|
||||
function round(answer, updatedAt = NOW_SECONDS) {
|
||||
return { answer, updatedAt };
|
||||
}
|
||||
|
||||
// One JSON-RPC answer, to a latestRoundData() call.
|
||||
function reply(req) {
|
||||
const envelope = { jsonrpc: "2.0", id: req.id };
|
||||
const answer = rounds[req.params[0].to.toLowerCase()];
|
||||
if (!answer) {
|
||||
return {
|
||||
...envelope,
|
||||
error: { code: -32000, message: "fixture: read failed" },
|
||||
};
|
||||
}
|
||||
return {
|
||||
...envelope,
|
||||
result: AbiCoder.defaultAbiCoder().encode(
|
||||
["uint80", "int256", "uint256", "uint256", "uint80"],
|
||||
[1, answer.answer, answer.updatedAt, answer.updatedAt, 1],
|
||||
),
|
||||
};
|
||||
}
|
||||
|
||||
// The feed addresses one HTTP request read, sorted.
|
||||
function feedsRead(body) {
|
||||
return [body]
|
||||
.flat()
|
||||
.map((req) => req.params[0].to.toLowerCase())
|
||||
.sort();
|
||||
}
|
||||
|
||||
// One address that holds `held`, a list of [contract address, symbol].
|
||||
function holdTokens(held) {
|
||||
state.wallets = [
|
||||
{
|
||||
addresses: [
|
||||
{
|
||||
address: "0x" + "a".repeat(40),
|
||||
balance: "1.0",
|
||||
tokenBalances: held.map(([address, symbol]) => ({
|
||||
address,
|
||||
symbol,
|
||||
balance: "10.0",
|
||||
})),
|
||||
},
|
||||
],
|
||||
},
|
||||
];
|
||||
}
|
||||
|
||||
beforeEach(() => {
|
||||
clearPrices();
|
||||
state.networkId = "mainnet";
|
||||
state.rpcUrl = RPC_URL;
|
||||
state.wallets = [];
|
||||
state.trackedTokens = [];
|
||||
rounds = { [ETH_FEED]: round(2000n * 10n ** 8n) };
|
||||
requests = [];
|
||||
logged = [];
|
||||
jest.spyOn(Date, "now").mockReturnValue(NOW);
|
||||
for (const level of ["error", "warn"]) {
|
||||
jest.spyOn(console, level).mockImplementation((...args) => {
|
||||
logged.push(args.map(String).join(" "));
|
||||
});
|
||||
}
|
||||
FetchRequest.registerGetUrl(async (req) => {
|
||||
const body = JSON.parse(Buffer.from(req.body).toString("utf8"));
|
||||
requests.push(body);
|
||||
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)),
|
||||
};
|
||||
});
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
FetchRequest.registerGetUrl(FetchRequest.createGetUrlFunc());
|
||||
jest.restoreAllMocks();
|
||||
clearPrices();
|
||||
});
|
||||
|
||||
describe("refreshPrices", () => {
|
||||
test("reads ETH and each held or tracked token that has a feed in one HTTP request", async () => {
|
||||
holdTokens([
|
||||
[USDC, "USDC"],
|
||||
[LINK, "LINK"],
|
||||
]);
|
||||
state.trackedTokens = [{ address: DAI, symbol: "DAI", decimals: 18 }];
|
||||
rounds[USDC_FEED] = round(10n ** 8n);
|
||||
rounds[LINK_FEED] = round(1150000000n);
|
||||
rounds[DAI_FEED] = round(99990000n);
|
||||
|
||||
await refreshPrices();
|
||||
|
||||
expect(requests).toHaveLength(1);
|
||||
expect(feedsRead(requests[0])).toEqual(
|
||||
[ETH_FEED, USDC_FEED, LINK_FEED, DAI_FEED].sort(),
|
||||
);
|
||||
expect(getPrice("ETH")).toBe(2000);
|
||||
expect(getPrice(USDC)).toBe(1);
|
||||
expect(getPrice(LINK)).toBe(11.5);
|
||||
expect(getPrice(DAI)).toBe(0.9999);
|
||||
});
|
||||
|
||||
test("reads again only once 5 minutes have passed", async () => {
|
||||
await refreshPrices();
|
||||
Date.now.mockReturnValue(NOW + 299999);
|
||||
await refreshPrices();
|
||||
expect(requests).toHaveLength(1);
|
||||
|
||||
Date.now.mockReturnValue(NOW + 300000);
|
||||
rounds[ETH_FEED] = round(2100n * 10n ** 8n, NOW_SECONDS + 300);
|
||||
await refreshPrices();
|
||||
expect(requests).toHaveLength(2);
|
||||
expect(getPrice("ETH")).toBe(2100);
|
||||
});
|
||||
|
||||
test("on Sepolia, reads nothing and keeps no price", async () => {
|
||||
await refreshPrices();
|
||||
expect(getPrice("ETH")).toBe(2000);
|
||||
|
||||
state.networkId = "sepolia";
|
||||
await refreshPrices();
|
||||
expect(requests).toHaveLength(1);
|
||||
expect(Object.keys(prices)).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("pairing by contract address", () => {
|
||||
test("a token that copies a bundled token's symbol gets no price", async () => {
|
||||
holdTokens([
|
||||
[USDC, "USDC"],
|
||||
[FAKE_USDC, "USDC"],
|
||||
]);
|
||||
rounds[USDC_FEED] = round(10n ** 8n);
|
||||
|
||||
await refreshPrices();
|
||||
|
||||
expect(feedsRead(requests[0])).toEqual([ETH_FEED, USDC_FEED].sort());
|
||||
expect(getPrice(USDC)).toBe(1);
|
||||
expect(getPrice(FAKE_USDC)).toBeNull();
|
||||
// 1 ETH and 10 real USDC are priced; the 10 look-alikes are not.
|
||||
expect(getAddressValue(state.wallets[0].addresses[0])).toEqual({
|
||||
usd: 2010,
|
||||
partial: true,
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("freshness", () => {
|
||||
test("a reading older than its feed's heartbeat plus 30 minutes is no price", async () => {
|
||||
const heartbeatAgo =
|
||||
NOW_SECONDS - PRICE_FEED_BY_ADDRESS.get(USDC).heartbeat;
|
||||
holdTokens([[USDC, "USDC"]]);
|
||||
|
||||
rounds[USDC_FEED] = round(10n ** 8n, heartbeatAgo - 1800 - 1);
|
||||
await refreshPrices();
|
||||
expect(getPrice(USDC)).toBeNull();
|
||||
|
||||
clearPrices();
|
||||
rounds[USDC_FEED] = round(10n ** 8n, heartbeatAgo - 1800);
|
||||
await refreshPrices();
|
||||
expect(getPrice(USDC)).toBe(1);
|
||||
});
|
||||
|
||||
test.each([0n, -1n])("an answer of %s is no price", async (answer) => {
|
||||
rounds[ETH_FEED] = round(answer);
|
||||
await refreshPrices();
|
||||
expect(getPrice("ETH")).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe("a failed read", () => {
|
||||
test("leaves the token with no price and is logged with its error", async () => {
|
||||
holdTokens([[USDC, "USDC"]]);
|
||||
rounds[USDC_FEED] = round(10n ** 8n);
|
||||
await refreshPrices();
|
||||
expect(getPrice(USDC)).toBe(1);
|
||||
|
||||
Date.now.mockReturnValue(NOW + 300000);
|
||||
delete rounds[USDC_FEED];
|
||||
await refreshPrices();
|
||||
|
||||
expect(getPrice(USDC)).toBeNull();
|
||||
expect(getPrice("ETH")).toBe(2000);
|
||||
expect(
|
||||
logged.some(
|
||||
(line) =>
|
||||
line.includes("price feed read failed") &&
|
||||
line.includes(USDC),
|
||||
),
|
||||
).toBe(true);
|
||||
});
|
||||
|
||||
test("an HTTP error is logged with its status", async () => {
|
||||
FetchRequest.registerGetUrl(async () => ({
|
||||
statusCode: 401,
|
||||
statusMessage: "Unauthorized",
|
||||
headers: { "content-type": "text/plain" },
|
||||
body: Buffer.from("API key required"),
|
||||
}));
|
||||
|
||||
await refreshPrices();
|
||||
|
||||
expect(getPrice("ETH")).toBeNull();
|
||||
expect(logged.some((line) => line.includes("401"))).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe("the feed table", () => {
|
||||
test("names each token by its address as the bundled list spells it", () => {
|
||||
const listed = new Set(TOKENS.map((t) => t.address));
|
||||
const unlisted = Object.keys(USD_PRICE_FEEDS).filter(
|
||||
(address) => !listed.has(address),
|
||||
);
|
||||
expect(unlisted).toEqual([]);
|
||||
});
|
||||
});
|
||||
@@ -1,157 +0,0 @@
|
||||
// While a refresh runs, a request through ctx is not dropped. One more refresh
|
||||
// runs once the running one ends, however many were asked for in that time
|
||||
// (https://git.eeqj.de/sneak/AutistMask/issues/581). A tick of the ten-second
|
||||
// timer that finds a refresh running is dropped. Each test boots the real popup
|
||||
// over a stored profile and holds the ten-second refresh open. `readChain()`
|
||||
// sets each address's balance from `CHAIN`, as the real `refreshBalances()`
|
||||
// sets it from the node.
|
||||
|
||||
const {
|
||||
bootPopup,
|
||||
cleanupPopup,
|
||||
unversionedValidProfile,
|
||||
ADDRESS,
|
||||
} = require("./support/popupBoot");
|
||||
const {
|
||||
hdWalletFromMnemonic,
|
||||
deriveAddressFromXpub,
|
||||
} = require("../src/shared/wallet");
|
||||
|
||||
const PHRASE =
|
||||
"abandon abandon abandon abandon abandon abandon " +
|
||||
"abandon abandon abandon abandon abandon about";
|
||||
const PASSWORD = "correct horse battery staple";
|
||||
|
||||
// The first two addresses of PHRASE, both used on the chain.
|
||||
const { xpub, firstAddress } = hdWalletFromMnemonic(PHRASE);
|
||||
const SECOND_ADDRESS = deriveAddressFromXpub(xpub, 1);
|
||||
|
||||
// The ETH balance the chain holds for each address, in ether.
|
||||
const CHAIN = {
|
||||
[ADDRESS]: "1.5",
|
||||
[firstAddress]: "2.0",
|
||||
[SECOND_ADDRESS]: "3.0",
|
||||
};
|
||||
|
||||
afterEach(() => {
|
||||
cleanupPopup();
|
||||
});
|
||||
|
||||
// The balance stand-in for a refresh that returns.
|
||||
async function readChain(wallets) {
|
||||
for (const wallet of wallets) {
|
||||
for (const addr of wallet.addresses) {
|
||||
addr.balance = CHAIN[addr.address];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Boots the popup over a profile with one wallet. From then on,
|
||||
// `refreshBalances()` never returns unless the test answers it. So an unwanted
|
||||
// refresh is counted once and then waits, instead of starting more.
|
||||
async function boot() {
|
||||
const page = await bootPopup(unversionedValidProfile());
|
||||
expect(page.pageErrors).toEqual([]);
|
||||
const { refreshBalances } = require("../src/shared/balances");
|
||||
refreshBalances.mockImplementation(() => new Promise(() => {}));
|
||||
return { page, refreshBalances };
|
||||
}
|
||||
|
||||
// Starts the ten-second refresh and holds it open until finish() is called.
|
||||
// The held refresh then writes the chain's balances. finish() resolves once
|
||||
// the held refresh has saved them and drawn Home. The one refresh after the
|
||||
// held one also returns.
|
||||
async function holdRefresh(page) {
|
||||
const { refreshBalances } = require("../src/shared/balances");
|
||||
let answer;
|
||||
refreshBalances
|
||||
.mockImplementationOnce(async (wallets) => {
|
||||
await new Promise((resolve) => {
|
||||
answer = resolve;
|
||||
});
|
||||
await readChain(wallets);
|
||||
})
|
||||
.mockImplementationOnce(readChain);
|
||||
const ticking = page.tick();
|
||||
await page.settle();
|
||||
return {
|
||||
finish: async () => {
|
||||
answer();
|
||||
await ticking;
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
// Imports PHRASE on AddWallet. Its address scan finds the phrase's first two
|
||||
// addresses.
|
||||
async function importPhrase(page) {
|
||||
const { scanForAddresses } = require("../src/shared/balances");
|
||||
scanForAddresses.mockImplementationOnce(async () => ({
|
||||
addresses: [
|
||||
{ address: firstAddress, index: 0 },
|
||||
{ address: SECOND_ADDRESS, index: 1 },
|
||||
],
|
||||
nextIndex: 2,
|
||||
}));
|
||||
await page.click("btn-add-wallet-bottom");
|
||||
await page.click("tab-mnemonic");
|
||||
page.node("wallet-mnemonic").value = PHRASE;
|
||||
page.node("add-wallet-password").value = PASSWORD;
|
||||
page.node("add-wallet-password-confirm").value = PASSWORD;
|
||||
await page.click("btn-add-wallet-confirm");
|
||||
}
|
||||
|
||||
// Imports the private key `key` on AddWallet.
|
||||
async function importKey(page, key) {
|
||||
await page.click("btn-add-wallet-bottom");
|
||||
await page.click("tab-privkey");
|
||||
page.node("import-private-key").value = key;
|
||||
page.node("add-wallet-password").value = PASSWORD;
|
||||
page.node("add-wallet-password-confirm").value = PASSWORD;
|
||||
await page.click("btn-add-wallet-confirm");
|
||||
}
|
||||
|
||||
test("addresses that an import finds during a refresh show their balances once one more refresh returns", async () => {
|
||||
const { page } = await boot();
|
||||
const refresh = await holdRefresh(page);
|
||||
|
||||
await importPhrase(page);
|
||||
expect(page.visibleViews()).toEqual(["main"]);
|
||||
expect(page.text("flash-msg")).toBe("Found 2 addresses.");
|
||||
|
||||
await refresh.finish();
|
||||
await page.settle();
|
||||
|
||||
const list = page.node("wallet-list").innerHTML;
|
||||
expect(list).toContain("<span>2.0000</span>");
|
||||
expect(list).toContain("<span>3.0000</span>");
|
||||
});
|
||||
|
||||
test("several requests during a refresh lead to exactly one more refresh", async () => {
|
||||
const { page, refreshBalances } = await boot();
|
||||
const refresh = await holdRefresh(page);
|
||||
const calls = refreshBalances.mock.calls.length;
|
||||
|
||||
await importKey(page, "0x" + "11".repeat(32));
|
||||
await importKey(page, "0x" + "22".repeat(32));
|
||||
await importPhrase(page);
|
||||
expect(refreshBalances).toHaveBeenCalledTimes(calls);
|
||||
|
||||
await refresh.finish();
|
||||
await page.settle();
|
||||
|
||||
expect(refreshBalances).toHaveBeenCalledTimes(calls + 1);
|
||||
});
|
||||
|
||||
test("a tick of the ten-second timer during a refresh starts no other refresh", async () => {
|
||||
const { page, refreshBalances } = await boot();
|
||||
const refresh = await holdRefresh(page);
|
||||
const calls = refreshBalances.mock.calls.length;
|
||||
|
||||
await page.tick();
|
||||
|
||||
await refresh.finish();
|
||||
await page.settle();
|
||||
|
||||
expect(refreshBalances).toHaveBeenCalledTimes(calls);
|
||||
});
|
||||
@@ -67,15 +67,13 @@ beforeEach(() => {
|
||||
});
|
||||
|
||||
describe("resolveTokenSymbol", () => {
|
||||
// The bundled list is read only for a token on Ethereum Mainnet.
|
||||
test("reads the bundled list", () => {
|
||||
expect(resolveTokenSymbol(USDC, { chainId: "0x1" })).toBe("USDC");
|
||||
expect(resolveTokenSymbol(USDC, state)).toBe("USDC");
|
||||
});
|
||||
|
||||
test("prefers the bundled list over a tracked entry", () => {
|
||||
state.trackedTokens = [{ address: USDC, symbol: "NOTUSDC" }];
|
||||
const sources = { chainId: "0x1", trackedTokens: state.trackedTokens };
|
||||
expect(resolveTokenSymbol(USDC, sources)).toBe("USDC");
|
||||
expect(resolveTokenSymbol(USDC, state)).toBe("USDC");
|
||||
});
|
||||
|
||||
test("reads a token the user tracks", () => {
|
||||
@@ -106,19 +104,7 @@ describe("resolveTokenSymbol", () => {
|
||||
test("rejects a tracked entry claiming a bundled ticker it is not", () => {
|
||||
// NOVEL_TOKEN is not the real USDC contract, so it may not wear USDC.
|
||||
state.trackedTokens = [{ address: NOVEL_TOKEN, symbol: "USDC" }];
|
||||
const sources = { chainId: "0x1", trackedTokens: state.trackedTokens };
|
||||
expect(resolveTokenSymbol(NOVEL_TOKEN, sources)).toBeNull();
|
||||
});
|
||||
|
||||
// The bundled list holds mainnet contracts, so on Sepolia any contract may
|
||||
// carry one of its symbols.
|
||||
test("on Sepolia, reads a tracked entry carrying a bundled ticker", () => {
|
||||
state.trackedTokens = [{ address: NOVEL_TOKEN, symbol: "USDC" }];
|
||||
const sources = {
|
||||
chainId: "0xaa36a7",
|
||||
trackedTokens: state.trackedTokens,
|
||||
};
|
||||
expect(resolveTokenSymbol(NOVEL_TOKEN, sources)).toBe("USDC");
|
||||
expect(resolveTokenSymbol(NOVEL_TOKEN, state)).toBeNull();
|
||||
});
|
||||
|
||||
test("rejects an explorer entry claiming the native ETH ticker", () => {
|
||||
|
||||
@@ -131,14 +131,10 @@ async function review(amount, token) {
|
||||
async function confirm(amount, token) {
|
||||
const txInfo = await review("0.5", token);
|
||||
confirmTx.show({ ...txInfo, amount });
|
||||
for (let i = 0; i < 10; i++) await jest.advanceTimersByTimeAsync(0);
|
||||
for (let i = 0; i < 10; i++) await new Promise((r) => setTimeout(r, 0));
|
||||
}
|
||||
|
||||
// showFlash() starts a timer that clears the message two seconds later. Each
|
||||
// test here runs on fake timers and drops them in afterEach, so that timer
|
||||
// never outlives the test.
|
||||
beforeEach(() => {
|
||||
jest.useFakeTimers();
|
||||
elements.clear();
|
||||
state.wallets = [
|
||||
{
|
||||
@@ -171,10 +167,6 @@ beforeEach(() => {
|
||||
state.currentView = null;
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
jest.useRealTimers();
|
||||
});
|
||||
|
||||
describe.each([
|
||||
["1e-3", "ETH"],
|
||||
["1e-3", "TOK"],
|
||||
|
||||
@@ -277,18 +277,14 @@ async function review() {
|
||||
|
||||
// show() starts the fee estimate without awaiting it; this lets it settle.
|
||||
async function settle() {
|
||||
for (let i = 0; i < 10; i++) await jest.advanceTimersByTimeAsync(0);
|
||||
for (let i = 0; i < 10; i++) await new Promise((r) => setTimeout(r, 0));
|
||||
}
|
||||
|
||||
function canSend() {
|
||||
return !el("btn-confirm-send").disabled;
|
||||
}
|
||||
|
||||
// showFlash() starts a timer that clears the message two seconds later. Each
|
||||
// test here runs on fake timers and drops them in afterEach, so that timer
|
||||
// never outlives the test.
|
||||
beforeEach(() => {
|
||||
jest.useFakeTimers();
|
||||
elements.clear();
|
||||
log.errorf.mockClear();
|
||||
pageClosed = new AbortController();
|
||||
@@ -301,10 +297,6 @@ beforeEach(() => {
|
||||
mockNode.broadcast = [];
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
jest.useRealTimers();
|
||||
});
|
||||
|
||||
describe("Max on an ETH send", () => {
|
||||
test("fills in the exact balance minus the fee reserve", async () => {
|
||||
await refreshWith(BALANCE_WEI);
|
||||
|
||||
@@ -1,438 +0,0 @@
|
||||
// Another page stores a different RPC or Blockscout URL for the same network.
|
||||
// Then the user taps "Save" in Settings on this page, on the URL that this page
|
||||
// loaded. The URL on screen is stored, and the flash message reads "Saved."
|
||||
// (https://git.eeqj.de/sneak/AutistMask/issues/688). Driven through the real
|
||||
// popup over a stored profile on Ethereum Mainnet.
|
||||
|
||||
const {
|
||||
bootPopup,
|
||||
cleanupPopup,
|
||||
unversionedValidProfile,
|
||||
} = require("./support/popupBoot");
|
||||
const { NETWORKS } = require("../src/shared/networks");
|
||||
|
||||
afterEach(() => {
|
||||
cleanupPopup();
|
||||
});
|
||||
|
||||
test.each([
|
||||
{ button: "btn-save-rpc", input: "settings-rpc", field: "rpcUrl" },
|
||||
{
|
||||
button: "btn-save-blockscout",
|
||||
input: "settings-blockscout",
|
||||
field: "blockscoutUrl",
|
||||
},
|
||||
])(
|
||||
"$button stores the URL on screen after another page stored a different one",
|
||||
async ({ button, input, field }) => {
|
||||
const page = await bootPopup(unversionedValidProfile());
|
||||
await page.click("btn-settings");
|
||||
const url = page.value(input);
|
||||
// This write sends this page no storage change event.
|
||||
page.storage.write("autistmask", {
|
||||
...page.storage.read("autistmask"),
|
||||
[field]: "https://other-page.example.invalid",
|
||||
});
|
||||
// This answer passes both endpoint checks on Ethereum Mainnet. The RPC
|
||||
// check reads Ethereum Mainnet's chain id from it. The Blockscout check
|
||||
// reads `ok`.
|
||||
globalThis.fetch.mockResolvedValue({
|
||||
ok: true,
|
||||
json: async () => ({ result: NETWORKS.mainnet.chainId }),
|
||||
});
|
||||
|
||||
await page.click(button);
|
||||
|
||||
expect(page.storage.read("autistmask")[field]).toBe(url);
|
||||
expect(page.text("flash-msg")).toBe("Saved.");
|
||||
},
|
||||
);
|
||||
|
||||
// The user types a URL in Settings and taps "Save". While the check waits for
|
||||
// the endpoint's answer, another page turns "Use Blockscout" on. This page
|
||||
// follows that change and draws Settings again, with the stored URL in the
|
||||
// input. The check then passes. The typed URL is not stored. The flash message
|
||||
// says that the URL was changed during the check
|
||||
// (https://git.eeqj.de/sneak/AutistMask/issues/695).
|
||||
test.each([
|
||||
{ button: "btn-save-rpc", input: "settings-rpc", field: "rpcUrl" },
|
||||
{
|
||||
button: "btn-save-blockscout",
|
||||
input: "settings-blockscout",
|
||||
field: "blockscoutUrl",
|
||||
},
|
||||
])(
|
||||
"$button stores nothing when Settings is drawn again during the check",
|
||||
async ({ button, input, field }) => {
|
||||
const page = await bootPopup(unversionedValidProfile());
|
||||
await page.click("btn-settings");
|
||||
const storedUrl = page.value(input);
|
||||
let answer;
|
||||
globalThis.fetch.mockReturnValue(
|
||||
new Promise((resolve) => {
|
||||
answer = resolve;
|
||||
}),
|
||||
);
|
||||
|
||||
page.node(input).value = "https://typed.example.invalid";
|
||||
const saving = page.node(button).listeners.click.map((fn) => fn());
|
||||
await page.settle();
|
||||
// The browser announces this write to this page.
|
||||
await page.storage.local.set({
|
||||
autistmask: {
|
||||
...page.storage.read("autistmask"),
|
||||
useBlockscout: true,
|
||||
},
|
||||
});
|
||||
await page.settle();
|
||||
expect(page.node("settings-use-blockscout").checked).toBe(true);
|
||||
// This answer passes both endpoint checks on Ethereum Mainnet.
|
||||
answer({
|
||||
ok: true,
|
||||
json: async () => ({ result: NETWORKS.mainnet.chainId }),
|
||||
});
|
||||
await Promise.all(saving);
|
||||
await page.settle();
|
||||
|
||||
expect(page.storage.read("autistmask")[field]).toBe(storedUrl);
|
||||
expect(page.value(input)).toBe(storedUrl);
|
||||
expect(page.text("flash-msg")).toBe(
|
||||
"The URL was not saved because it was changed during the check.",
|
||||
);
|
||||
},
|
||||
);
|
||||
|
||||
// As above, but another write holds the lock. So this page's follow of the
|
||||
// change to "Use Blockscout" waits for the lock. The endpoint answers while the
|
||||
// input still shows the typed URL. The save then asks for the lock, after the
|
||||
// follow did. So the follow draws Settings again before the save compares the
|
||||
// input.
|
||||
test.each([
|
||||
{ button: "btn-save-rpc", input: "settings-rpc", field: "rpcUrl" },
|
||||
{
|
||||
button: "btn-save-blockscout",
|
||||
input: "settings-blockscout",
|
||||
field: "blockscoutUrl",
|
||||
},
|
||||
])(
|
||||
"$button stores nothing when Settings is drawn again while the save waits for the lock",
|
||||
async ({ button, input, field }) => {
|
||||
const page = await bootPopup(unversionedValidProfile());
|
||||
await page.click("btn-settings");
|
||||
const storedUrl = page.value(input);
|
||||
let answer;
|
||||
globalThis.fetch.mockReturnValue(
|
||||
new Promise((resolve) => {
|
||||
answer = resolve;
|
||||
}),
|
||||
);
|
||||
const typedUrl = "https://typed.example.invalid";
|
||||
|
||||
page.node(input).value = typedUrl;
|
||||
const saving = page.node(button).listeners.click.map((fn) => fn());
|
||||
await page.settle();
|
||||
let releaseLock;
|
||||
const lockHeld = navigator.locks.request(
|
||||
"autistmask",
|
||||
() =>
|
||||
new Promise((resolve) => {
|
||||
releaseLock = resolve;
|
||||
}),
|
||||
);
|
||||
// The browser announces this write to this page.
|
||||
await page.storage.local.set({
|
||||
autistmask: {
|
||||
...page.storage.read("autistmask"),
|
||||
useBlockscout: true,
|
||||
},
|
||||
});
|
||||
await page.settle();
|
||||
// This answer passes both endpoint checks on Ethereum Mainnet.
|
||||
answer({
|
||||
ok: true,
|
||||
json: async () => ({ result: NETWORKS.mainnet.chainId }),
|
||||
});
|
||||
await page.settle();
|
||||
expect(page.value(input)).toBe(typedUrl);
|
||||
releaseLock();
|
||||
await lockHeld;
|
||||
await Promise.all(saving);
|
||||
await page.settle();
|
||||
|
||||
expect(page.node("settings-use-blockscout").checked).toBe(true);
|
||||
expect(page.storage.read("autistmask")[field]).toBe(storedUrl);
|
||||
expect(page.value(input)).toBe(storedUrl);
|
||||
expect(page.text("flash-msg")).toBe(
|
||||
"The URL was not saved because it was changed during the check.",
|
||||
);
|
||||
},
|
||||
);
|
||||
|
||||
// This answer passes both endpoint checks on Ethereum Mainnet.
|
||||
const PASSING_ANSWER = {
|
||||
ok: true,
|
||||
json: async () => ({ result: NETWORKS.mainnet.chainId }),
|
||||
};
|
||||
|
||||
// Both endpoint checks read this answer as an error. The RPC check reads the
|
||||
// answer's `error`. The Blockscout check reads the answer's `ok`.
|
||||
const ERROR_ANSWER = {
|
||||
ok: false,
|
||||
status: 500,
|
||||
json: async () => ({ error: { code: -32603, message: "Internal error" } }),
|
||||
};
|
||||
|
||||
// The user types a URL in Settings and taps "Save". Before the endpoint answers,
|
||||
// the user types a second URL and taps "Save" again. The second check passes
|
||||
// first. The second URL is stored, and the flash message reads "Saved.". The
|
||||
// first check then ends in one of three ways:
|
||||
//
|
||||
// - It passes.
|
||||
// - It fails, because fetch cannot reach the endpoint.
|
||||
// - It gets an answer that holds an error.
|
||||
//
|
||||
// None of the three changes the stored URL or the flash message
|
||||
// (https://git.eeqj.de/sneak/AutistMask/issues/698).
|
||||
test.each([
|
||||
{
|
||||
button: "btn-save-rpc",
|
||||
input: "settings-rpc",
|
||||
field: "rpcUrl",
|
||||
first: "passes",
|
||||
},
|
||||
{
|
||||
button: "btn-save-rpc",
|
||||
input: "settings-rpc",
|
||||
field: "rpcUrl",
|
||||
first: "fails",
|
||||
},
|
||||
{
|
||||
button: "btn-save-rpc",
|
||||
input: "settings-rpc",
|
||||
field: "rpcUrl",
|
||||
first: "answers with an error",
|
||||
},
|
||||
{
|
||||
button: "btn-save-blockscout",
|
||||
input: "settings-blockscout",
|
||||
field: "blockscoutUrl",
|
||||
first: "passes",
|
||||
},
|
||||
{
|
||||
button: "btn-save-blockscout",
|
||||
input: "settings-blockscout",
|
||||
field: "blockscoutUrl",
|
||||
first: "fails",
|
||||
},
|
||||
{
|
||||
button: "btn-save-blockscout",
|
||||
input: "settings-blockscout",
|
||||
field: "blockscoutUrl",
|
||||
first: "answers with an error",
|
||||
},
|
||||
])(
|
||||
"$button keeps the second tap's result when the first check $first last",
|
||||
async ({ button, input, field, first }) => {
|
||||
const page = await bootPopup(unversionedValidProfile());
|
||||
await page.click("btn-settings");
|
||||
const checks = [];
|
||||
globalThis.fetch.mockImplementation(
|
||||
() =>
|
||||
new Promise((resolve, reject) => {
|
||||
checks.push({ resolve, reject });
|
||||
}),
|
||||
);
|
||||
const secondUrl = "https://second.example.invalid";
|
||||
|
||||
page.node(input).value = "https://first.example.invalid";
|
||||
const firstTap = page.node(button).listeners.click.map((fn) => fn());
|
||||
await page.settle();
|
||||
page.node(input).value = secondUrl;
|
||||
const secondTap = page.node(button).listeners.click.map((fn) => fn());
|
||||
await page.settle();
|
||||
checks[1].resolve(PASSING_ANSWER);
|
||||
await Promise.all(secondTap);
|
||||
await page.settle();
|
||||
expect(page.text("flash-msg")).toBe("Saved.");
|
||||
if (first === "passes") {
|
||||
checks[0].resolve(PASSING_ANSWER);
|
||||
} else if (first === "answers with an error") {
|
||||
checks[0].resolve(ERROR_ANSWER);
|
||||
} else {
|
||||
// fetch rejects when it cannot reach the endpoint.
|
||||
checks[0].reject(new TypeError("Failed to fetch"));
|
||||
}
|
||||
await Promise.all(firstTap);
|
||||
await page.settle();
|
||||
|
||||
expect(checks).toHaveLength(2);
|
||||
expect(page.storage.read("autistmask")[field]).toBe(secondUrl);
|
||||
expect(page.text("flash-msg")).toBe("Saved.");
|
||||
},
|
||||
);
|
||||
|
||||
// The user types a URL in Settings and taps "Save". Before the endpoint answers,
|
||||
// the user empties the input and taps "Save" again. The flash message asks for
|
||||
// a URL. The first check then passes. The flash message still asks for a URL,
|
||||
// and the stored URL is unchanged.
|
||||
test.each([
|
||||
{
|
||||
button: "btn-save-rpc",
|
||||
input: "settings-rpc",
|
||||
field: "rpcUrl",
|
||||
message: "Please enter an RPC URL.",
|
||||
},
|
||||
{
|
||||
button: "btn-save-blockscout",
|
||||
input: "settings-blockscout",
|
||||
field: "blockscoutUrl",
|
||||
message: "Please enter a Blockscout API URL.",
|
||||
},
|
||||
])(
|
||||
"$button keeps the empty-input message when the first check passes last",
|
||||
async ({ button, input, field, message }) => {
|
||||
const page = await bootPopup(unversionedValidProfile());
|
||||
await page.click("btn-settings");
|
||||
const storedUrl = page.value(input);
|
||||
let answer;
|
||||
globalThis.fetch.mockReturnValue(
|
||||
new Promise((resolve) => {
|
||||
answer = resolve;
|
||||
}),
|
||||
);
|
||||
|
||||
page.node(input).value = "https://typed.example.invalid";
|
||||
const firstTap = page.node(button).listeners.click.map((fn) => fn());
|
||||
await page.settle();
|
||||
page.node(input).value = "";
|
||||
await page.click(button);
|
||||
expect(page.text("flash-msg")).toBe(message);
|
||||
answer(PASSING_ANSWER);
|
||||
await Promise.all(firstTap);
|
||||
await page.settle();
|
||||
|
||||
expect(page.storage.read("autistmask")[field]).toBe(storedUrl);
|
||||
expect(page.text("flash-msg")).toBe(message);
|
||||
},
|
||||
);
|
||||
|
||||
// The user types a URL in Settings and taps "Save". Another write holds the
|
||||
// lock. So the save waits for the lock once the check passes. The user then
|
||||
// taps "Save" again on the same URL. When the lock is free, the first save
|
||||
// stores nothing and shows no flash message. The second check then passes, and
|
||||
// the second save stores the URL.
|
||||
test.each([
|
||||
{ button: "btn-save-rpc", input: "settings-rpc", field: "rpcUrl" },
|
||||
{
|
||||
button: "btn-save-blockscout",
|
||||
input: "settings-blockscout",
|
||||
field: "blockscoutUrl",
|
||||
},
|
||||
])(
|
||||
"$button stores nothing for an earlier tap still waiting for the lock",
|
||||
async ({ button, input, field }) => {
|
||||
const page = await bootPopup(unversionedValidProfile());
|
||||
await page.click("btn-settings");
|
||||
const storedUrl = page.value(input);
|
||||
const checks = [];
|
||||
globalThis.fetch.mockImplementation(
|
||||
() =>
|
||||
new Promise((resolve) => {
|
||||
checks.push(resolve);
|
||||
}),
|
||||
);
|
||||
const typedUrl = "https://typed.example.invalid";
|
||||
|
||||
page.node(input).value = typedUrl;
|
||||
const firstTap = page.node(button).listeners.click.map((fn) => fn());
|
||||
await page.settle();
|
||||
let releaseLock;
|
||||
const lockHeld = navigator.locks.request(
|
||||
"autistmask",
|
||||
() =>
|
||||
new Promise((resolve) => {
|
||||
releaseLock = resolve;
|
||||
}),
|
||||
);
|
||||
checks[0](PASSING_ANSWER);
|
||||
await page.settle();
|
||||
const secondTap = page.node(button).listeners.click.map((fn) => fn());
|
||||
await page.settle();
|
||||
releaseLock();
|
||||
await lockHeld;
|
||||
await Promise.all(firstTap);
|
||||
await page.settle();
|
||||
|
||||
expect(page.storage.read("autistmask")[field]).toBe(storedUrl);
|
||||
expect(page.text("flash-msg")).toBe("Testing endpoint...");
|
||||
|
||||
checks[1](PASSING_ANSWER);
|
||||
await Promise.all(secondTap);
|
||||
await page.settle();
|
||||
|
||||
expect(checks).toHaveLength(2);
|
||||
expect(page.storage.read("autistmask")[field]).toBe(typedUrl);
|
||||
expect(page.text("flash-msg")).toBe("Saved.");
|
||||
},
|
||||
);
|
||||
|
||||
// The user taps "Save", and the check passes. The save then begins its storage
|
||||
// write, and this test keeps the write waiting. The user taps "Save" again, and
|
||||
// the second check cannot reach the endpoint. When the write ends, the flash
|
||||
// message still reads "Could not reach endpoint.". The write stores the URL
|
||||
// anyway, because the write began before the second tap.
|
||||
test.each([
|
||||
{ button: "btn-save-rpc", input: "settings-rpc", field: "rpcUrl" },
|
||||
{
|
||||
button: "btn-save-blockscout",
|
||||
input: "settings-blockscout",
|
||||
field: "blockscoutUrl",
|
||||
},
|
||||
])(
|
||||
"$button keeps the second tap's message when tapped again during the write",
|
||||
async ({ button, input, field }) => {
|
||||
const page = await bootPopup(unversionedValidProfile());
|
||||
await page.click("btn-settings");
|
||||
const checks = [];
|
||||
globalThis.fetch.mockImplementation(
|
||||
() =>
|
||||
new Promise((resolve, reject) => {
|
||||
checks.push({ resolve, reject });
|
||||
}),
|
||||
);
|
||||
const typedUrl = "https://typed.example.invalid";
|
||||
|
||||
page.node(input).value = typedUrl;
|
||||
const firstTap = page.node(button).listeners.click.map((fn) => fn());
|
||||
await page.settle();
|
||||
const { set } = page.storage.local;
|
||||
const write = set.getMockImplementation();
|
||||
let writeBegan = false;
|
||||
let releaseWrite;
|
||||
const writeHeld = new Promise((resolve) => {
|
||||
releaseWrite = resolve;
|
||||
});
|
||||
set.mockImplementationOnce(async (items) => {
|
||||
writeBegan = true;
|
||||
await writeHeld;
|
||||
await write(items);
|
||||
});
|
||||
checks[0].resolve(PASSING_ANSWER);
|
||||
await page.settle();
|
||||
expect(writeBegan).toBe(true);
|
||||
const secondTap = page.node(button).listeners.click.map((fn) => fn());
|
||||
await page.settle();
|
||||
// fetch rejects when it cannot reach the endpoint.
|
||||
checks[1].reject(new TypeError("Failed to fetch"));
|
||||
await Promise.all(secondTap);
|
||||
await page.settle();
|
||||
expect(page.text("flash-msg")).toBe("Could not reach endpoint.");
|
||||
releaseWrite();
|
||||
await Promise.all(firstTap);
|
||||
await page.settle();
|
||||
|
||||
expect(checks).toHaveLength(2);
|
||||
expect(page.storage.read("autistmask")[field]).toBe(typedUrl);
|
||||
expect(page.text("flash-msg")).toBe("Could not reach endpoint.");
|
||||
},
|
||||
);
|
||||
@@ -1,134 +0,0 @@
|
||||
// A token that the spoof rule refuses never shows in the balance list, even
|
||||
// tracked at zero balance with "Show tracked tokens with zero balance" on, and
|
||||
// the two add-token screens refuse to track one
|
||||
// (https://git.eeqj.de/sneak/AutistMask/issues/705). Driven through the real
|
||||
// popup over a stored profile.
|
||||
|
||||
const {
|
||||
bootPopup,
|
||||
cleanupPopup,
|
||||
unversionedValidProfile,
|
||||
TOKEN_ADDRESS,
|
||||
} = require("./support/popupBoot");
|
||||
|
||||
// Claims the symbol of the bundled USDT from another contract.
|
||||
const FAKE_USDT = {
|
||||
address: TOKEN_ADDRESS,
|
||||
symbol: "USDT",
|
||||
decimals: 6,
|
||||
name: "Tether USD",
|
||||
};
|
||||
// A Sepolia contract that reports USDT. The bundled list holds Ethereum Mainnet
|
||||
// contracts, so the spoof rule does not check this symbol on Sepolia
|
||||
// (https://git.eeqj.de/sneak/AutistMask/issues/632).
|
||||
const SEPOLIA_USDT = {
|
||||
address: TOKEN_ADDRESS,
|
||||
symbol: "USDT",
|
||||
decimals: 6,
|
||||
name: "Test USDT",
|
||||
};
|
||||
// A symbol the bundled list does not have, so the spoof rule passes it.
|
||||
const TEST_TOKEN = {
|
||||
address: "0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
|
||||
symbol: "TST",
|
||||
decimals: 18,
|
||||
name: "Test Token",
|
||||
};
|
||||
const REFUSED_FLASH = "Not added: this token fakes a known symbol.";
|
||||
|
||||
afterEach(() => {
|
||||
cleanupPopup();
|
||||
});
|
||||
|
||||
test("on Ethereum Mainnet, a fake token tracked at zero balance is not listed while zero balances are shown", async () => {
|
||||
const boot = await bootPopup(
|
||||
unversionedValidProfile({
|
||||
networkId: "mainnet",
|
||||
currentView: "address",
|
||||
selectedWallet: 0,
|
||||
selectedAddress: 0,
|
||||
trackedTokens: [FAKE_USDT, TEST_TOKEN],
|
||||
showZeroBalanceTokens: true,
|
||||
}),
|
||||
);
|
||||
const rows = boot.node("address-balances").innerHTML;
|
||||
expect(rows).toContain(`data-token="${TEST_TOKEN.address.toLowerCase()}"`);
|
||||
expect(rows).not.toContain(
|
||||
`data-token="${FAKE_USDT.address.toLowerCase()}"`,
|
||||
);
|
||||
});
|
||||
|
||||
// Each screen is opened from AddressDetail by the buttons named, in order.
|
||||
describe.each([
|
||||
[
|
||||
"AddToken",
|
||||
["btn-add-token"],
|
||||
"add-token",
|
||||
"add-token-address",
|
||||
"btn-add-token-confirm",
|
||||
],
|
||||
[
|
||||
"SettingsAddToken",
|
||||
["btn-settings", "btn-settings-add-token"],
|
||||
"settings-addtoken",
|
||||
"settings-addtoken-address",
|
||||
"btn-settings-addtoken-manual",
|
||||
],
|
||||
])("%s", (_, opening, view, field, button) => {
|
||||
test("on Ethereum Mainnet, refuses a fake token by contract address", async () => {
|
||||
const boot = await bootPopup(
|
||||
unversionedValidProfile({
|
||||
networkId: "mainnet",
|
||||
currentView: "address",
|
||||
selectedWallet: 0,
|
||||
selectedAddress: 0,
|
||||
}),
|
||||
);
|
||||
for (const id of opening) await boot.click(id);
|
||||
expect(boot.visibleViews()).toEqual([view]);
|
||||
const { lookupTokenInfo } = require("../src/shared/balances");
|
||||
lookupTokenInfo.mockResolvedValueOnce({
|
||||
symbol: FAKE_USDT.symbol,
|
||||
decimals: FAKE_USDT.decimals,
|
||||
name: FAKE_USDT.name,
|
||||
});
|
||||
boot.node(field).value = FAKE_USDT.address;
|
||||
|
||||
await boot.click(button);
|
||||
expect(boot.text("flash-msg")).toBe(REFUSED_FLASH);
|
||||
expect(boot.visibleViews()).toEqual([view]);
|
||||
expect(boot.storage.read("autistmask").trackedTokens).toEqual([]);
|
||||
});
|
||||
|
||||
test("on Sepolia, adds a contract that reports USDT and lists it", async () => {
|
||||
const boot = await bootPopup(
|
||||
unversionedValidProfile({
|
||||
networkId: "sepolia",
|
||||
currentView: "address",
|
||||
selectedWallet: 0,
|
||||
selectedAddress: 0,
|
||||
showZeroBalanceTokens: true,
|
||||
}),
|
||||
);
|
||||
for (const id of opening) await boot.click(id);
|
||||
expect(boot.visibleViews()).toEqual([view]);
|
||||
const { lookupTokenInfo } = require("../src/shared/balances");
|
||||
lookupTokenInfo.mockResolvedValueOnce({
|
||||
symbol: SEPOLIA_USDT.symbol,
|
||||
decimals: SEPOLIA_USDT.decimals,
|
||||
name: SEPOLIA_USDT.name,
|
||||
});
|
||||
boot.node(field).value = SEPOLIA_USDT.address;
|
||||
|
||||
await boot.click(button);
|
||||
expect(boot.text("flash-msg")).not.toBe(REFUSED_FLASH);
|
||||
expect(boot.storage.read("autistmask").trackedTokens).toEqual([
|
||||
expect.objectContaining(SEPOLIA_USDT),
|
||||
]);
|
||||
// SettingsAddToken stays up after adding, so this draws AddressDetail.
|
||||
require("../src/popup/views/addressDetail").show();
|
||||
expect(boot.node("address-balances").innerHTML).toContain(
|
||||
`data-token="${SEPOLIA_USDT.address.toLowerCase()}"`,
|
||||
);
|
||||
});
|
||||
});
|
||||
@@ -23,9 +23,6 @@
|
||||
// version field, and showing those users a wipe prompt would be a worse defect
|
||||
// than the one being fixed. It is migrated in place and keeps working.
|
||||
|
||||
const fs = require("fs");
|
||||
const path = require("path");
|
||||
|
||||
const {
|
||||
bootPopup,
|
||||
cleanupPopup,
|
||||
@@ -151,29 +148,6 @@ describe("the destructive reset on the recovery screen", () => {
|
||||
});
|
||||
});
|
||||
|
||||
// A key or xprv wallet has no recovery phrase, so the erase warning names all
|
||||
// three backups (https://git.eeqj.de/sneak/AutistMask/issues/593). The boot
|
||||
// harness holds no static text, so this reads the markup itself.
|
||||
describe("the erase warning on the recovery screen", () => {
|
||||
test("names the recovery phrase, the private key and the extended private key", () => {
|
||||
const html = fs.readFileSync(
|
||||
path.join(__dirname, "..", "src", "popup", "index.html"),
|
||||
"utf8",
|
||||
);
|
||||
const start = html.indexOf('id="view-state-recovery"');
|
||||
const end = html.indexOf('id="btn-state-recovery-reset"', start);
|
||||
const screenText = html
|
||||
.slice(start, end)
|
||||
.replace(/<[^>]*>/g, " ")
|
||||
.replace(/\s+/g, " ");
|
||||
|
||||
expect(screenText).toContain(
|
||||
"If you kept a copy of a wallet's recovery phrase, private key or " +
|
||||
"extended private key, you can add that wallet again.",
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe("a popup already open when the stored profile becomes unreadable", () => {
|
||||
// https://git.eeqj.de/sneak/AutistMask/issues/373. The popup used to stay
|
||||
// on the wallet list with the last good balances, and only a reopen
|
||||
|
||||
@@ -279,11 +279,10 @@ async function bootPopup(stored, options) {
|
||||
getAddressValue: () => ({ usd: null, partial: false }),
|
||||
}));
|
||||
// scanForAddresses() answers in the real one's shape, a scan that found
|
||||
// no used address: AddWallet reads `addresses` from it. refreshBalances()
|
||||
// answers as a refresh that read no tracked token's balance.
|
||||
// no used address: AddWallet reads `addresses` from it.
|
||||
jest.doMock("../../src/shared/balances", () => ({
|
||||
fetchTokenBalances: jest.fn(async () => []),
|
||||
refreshBalances: jest.fn(async () => []),
|
||||
refreshBalances: jest.fn(async () => {}),
|
||||
dropUntrackedTokens: jest.requireActual("../../src/shared/balances")
|
||||
.dropUntrackedTokens,
|
||||
lookupTokenInfo: jest.fn(async () => null),
|
||||
|
||||
+16
-110
@@ -72,11 +72,6 @@ const {
|
||||
const { renderSendTokenSelect } = require("../src/popup/views/send");
|
||||
const { state } = require("../src/shared/state");
|
||||
const { debugFetch } = require("../src/shared/log");
|
||||
const { NETWORKS } = require("../src/shared/networks");
|
||||
|
||||
// The bundled list's symbols are known symbols only on Ethereum Mainnet.
|
||||
const MAINNET = NETWORKS.mainnet.chainId;
|
||||
const SEPOLIA = NETWORKS.sepolia.chainId;
|
||||
|
||||
// The fake "Ethereum" token with symbol "ETH" from the attack documented in
|
||||
// README.md, given a holder count high enough to clear every other filter so
|
||||
@@ -121,29 +116,14 @@ describe("the shared rule", () => {
|
||||
});
|
||||
|
||||
test("a known symbol from its own contract is not a spoof", () => {
|
||||
expect(isSpoofedSymbol("USDC", USDC_CONTRACT, MAINNET)).toBe(false);
|
||||
expect(
|
||||
isSpoofedSymbol("usdc", USDC_CONTRACT.toUpperCase(), MAINNET),
|
||||
).toBe(false);
|
||||
expect(isSpoofedSymbol("USDC", USDC_CONTRACT)).toBe(false);
|
||||
expect(isSpoofedSymbol("usdc", USDC_CONTRACT.toUpperCase())).toBe(
|
||||
false,
|
||||
);
|
||||
});
|
||||
|
||||
test("a known symbol from another contract is a spoof", () => {
|
||||
expect(isSpoofedSymbol("USDC", FAKE_ETH_CONTRACT, MAINNET)).toBe(true);
|
||||
});
|
||||
|
||||
// https://git.eeqj.de/sneak/AutistMask/issues/632: the bundled list holds
|
||||
// mainnet contracts, so on Sepolia any contract may carry one of its
|
||||
// symbols.
|
||||
test("on Sepolia, a bundled symbol from any contract is not a spoof", () => {
|
||||
expect(isSpoofedSymbol("USDC", FAKE_ETH_CONTRACT, SEPOLIA)).toBe(false);
|
||||
expect(isSpoofedSymbol("USDC", USDC_CONTRACT, SEPOLIA)).toBe(false);
|
||||
});
|
||||
|
||||
test("on Sepolia, the native asset's labels are still reserved", () => {
|
||||
expect(isSpoofedSymbol("ETH", FAKE_ETH_CONTRACT, SEPOLIA)).toBe(true);
|
||||
expect(isSpoofedSymbol("SepoliaETH", FAKE_ETH_CONTRACT, SEPOLIA)).toBe(
|
||||
true,
|
||||
);
|
||||
expect(isSpoofedSymbol("USDC", FAKE_ETH_CONTRACT)).toBe(true);
|
||||
});
|
||||
|
||||
test("a symbol that is not in the table is not judged here", () => {
|
||||
@@ -184,9 +164,7 @@ describe("the shared rule: symbols that render as a known symbol", () => {
|
||||
test("ASCII padding does not buy a pass", () => {
|
||||
expect(isSpoofedSymbol(" ETH ", FAKE_ETH_CONTRACT)).toBe(true);
|
||||
expect(isSpoofedSymbol("\tETH\n", FAKE_ETH_CONTRACT)).toBe(true);
|
||||
expect(isSpoofedSymbol(" usdc ", FAKE_ETH_CONTRACT, MAINNET)).toBe(
|
||||
true,
|
||||
);
|
||||
expect(isSpoofedSymbol(" usdc ", FAKE_ETH_CONTRACT)).toBe(true);
|
||||
});
|
||||
|
||||
test("non-breaking and other Unicode spaces do not either", () => {
|
||||
@@ -265,9 +243,7 @@ describe("the shared rule: symbols that render as a known symbol", () => {
|
||||
|
||||
test("compatibility forms fold onto the symbol they imitate", () => {
|
||||
expect(isSpoofedSymbol(FULLWIDTH_ETH, FAKE_ETH_CONTRACT)).toBe(true);
|
||||
expect(
|
||||
isSpoofedSymbol(FULLWIDTH_USDC, FAKE_ETH_CONTRACT, MAINNET),
|
||||
).toBe(true);
|
||||
expect(isSpoofedSymbol(FULLWIDTH_USDC, FAKE_ETH_CONTRACT)).toBe(true);
|
||||
});
|
||||
|
||||
// The two knowingly open classes, asserted here so that the boundary is
|
||||
@@ -295,10 +271,8 @@ describe("the shared rule: symbols that render as a known symbol", () => {
|
||||
});
|
||||
|
||||
test("a genuine contract still bears its own padded symbol", () => {
|
||||
expect(isSpoofedSymbol(" USDC ", USDC_CONTRACT, MAINNET)).toBe(false);
|
||||
expect(isSpoofedSymbol(ZWSP + "WETH", WETH_CONTRACT, MAINNET)).toBe(
|
||||
false,
|
||||
);
|
||||
expect(isSpoofedSymbol(" USDC ", USDC_CONTRACT)).toBe(false);
|
||||
expect(isSpoofedSymbol(ZWSP + "WETH", WETH_CONTRACT)).toBe(false);
|
||||
});
|
||||
|
||||
// Normalization must not invent a match. Interior ASCII whitespace is
|
||||
@@ -322,7 +296,7 @@ describe("the shared rule: symbols that render as a known symbol", () => {
|
||||
expect(symbol).toMatch(/^[!-~]+$/);
|
||||
if (addresses === null) continue;
|
||||
for (const address of addresses) {
|
||||
expect(isSpoofedSymbol(symbol, address, MAINNET)).toBe(false);
|
||||
expect(isSpoofedSymbol(symbol, address)).toBe(false);
|
||||
}
|
||||
}
|
||||
});
|
||||
@@ -343,7 +317,7 @@ describe("the shared rule: symbols that render as a known symbol", () => {
|
||||
describe("the shipped token list", () => {
|
||||
test("no bundled token is filtered at its own address", () => {
|
||||
const filtered = TOKENS.filter((t) =>
|
||||
isSpoofedSymbol(t.symbol, t.address, MAINNET),
|
||||
isSpoofedSymbol(t.symbol, t.address),
|
||||
).map((t) => t.symbol + " @ " + t.address);
|
||||
expect(filtered).toEqual([]);
|
||||
});
|
||||
@@ -386,9 +360,7 @@ describe("the shipped token list", () => {
|
||||
expect(shared.length).toBeGreaterThan(0);
|
||||
for (const [, list] of shared) {
|
||||
for (const t of list) {
|
||||
expect(isSpoofedSymbol(t.symbol, t.address, MAINNET)).toBe(
|
||||
false,
|
||||
);
|
||||
expect(isSpoofedSymbol(t.symbol, t.address)).toBe(false);
|
||||
}
|
||||
}
|
||||
});
|
||||
@@ -432,7 +404,7 @@ describe("the shipped token list", () => {
|
||||
[...addresses].sort(),
|
||||
);
|
||||
for (const address of addresses) {
|
||||
expect(isSpoofedSymbol(symbol, address, MAINNET)).toBe(false);
|
||||
expect(isSpoofedSymbol(symbol, address)).toBe(false);
|
||||
}
|
||||
}
|
||||
});
|
||||
@@ -449,9 +421,7 @@ describe("the shipped token list", () => {
|
||||
}
|
||||
for (const [symbol, list] of bySymbol) {
|
||||
if (list.length < 2) continue;
|
||||
expect(isSpoofedSymbol(symbol, FAKE_ETH_CONTRACT, MAINNET)).toBe(
|
||||
true,
|
||||
);
|
||||
expect(isSpoofedSymbol(symbol, FAKE_ETH_CONTRACT)).toBe(true);
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -536,40 +506,10 @@ describe("surface 2: the Send token selector", () => {
|
||||
}
|
||||
|
||||
beforeEach(() => {
|
||||
state.networkId = "mainnet";
|
||||
state.fraudContracts = [];
|
||||
state.hideLowHolderTokens = true;
|
||||
});
|
||||
|
||||
afterAll(() => {
|
||||
state.networkId = "mainnet";
|
||||
});
|
||||
|
||||
// A token reporting USDC's symbol from another contract.
|
||||
function otherUsdc() {
|
||||
return {
|
||||
address: FAKE_ETH_CONTRACT,
|
||||
symbol: "USDC",
|
||||
decimals: 6,
|
||||
balance: "12.5",
|
||||
holders: 900000,
|
||||
};
|
||||
}
|
||||
|
||||
test("a bundled symbol from another contract is not selectable", () => {
|
||||
render([otherUsdc()]);
|
||||
expect(select.children).toEqual([]);
|
||||
});
|
||||
|
||||
// https://git.eeqj.de/sneak/AutistMask/issues/632: the bundled list holds
|
||||
// mainnet contracts, so on Sepolia any contract may carry its symbols.
|
||||
test("with Sepolia active, a bundled symbol from another contract is selectable", () => {
|
||||
state.networkId = "sepolia";
|
||||
render([otherUsdc()]);
|
||||
expect(select.children).toHaveLength(1);
|
||||
expect(select.children[0].value).toBe(FAKE_ETH_CONTRACT);
|
||||
});
|
||||
|
||||
test("a fake ETH token is not selectable", () => {
|
||||
render([
|
||||
{
|
||||
@@ -687,12 +627,7 @@ describe("surface 3: the balance list", () => {
|
||||
decimals: "6",
|
||||
}),
|
||||
]);
|
||||
const balances = await fetchTokenBalances(
|
||||
HOLDER,
|
||||
BLOCKSCOUT,
|
||||
[],
|
||||
MAINNET,
|
||||
);
|
||||
const balances = await fetchTokenBalances(HOLDER, BLOCKSCOUT, []);
|
||||
expect(balances).toHaveLength(1);
|
||||
expect(balances[0].symbol).toBe(" USDC ");
|
||||
});
|
||||
@@ -706,40 +641,11 @@ describe("surface 3: the balance list", () => {
|
||||
decimals: "6",
|
||||
}),
|
||||
]);
|
||||
const balances = await fetchTokenBalances(
|
||||
HOLDER,
|
||||
BLOCKSCOUT,
|
||||
[],
|
||||
MAINNET,
|
||||
);
|
||||
const balances = await fetchTokenBalances(HOLDER, BLOCKSCOUT, []);
|
||||
expect(balances).toHaveLength(1);
|
||||
expect(balances[0].symbol).toBe("USDC");
|
||||
});
|
||||
|
||||
// https://git.eeqj.de/sneak/AutistMask/issues/632: the bundled list holds
|
||||
// mainnet contracts, so on Sepolia any contract may carry its symbols.
|
||||
test("a bundled symbol from another contract is listed on Sepolia only", async () => {
|
||||
respondWith([fakeEthItem({ symbol: "USDC", decimals: "6" })]);
|
||||
expect(
|
||||
await fetchTokenBalances(HOLDER, BLOCKSCOUT, [], MAINNET),
|
||||
).toEqual([]);
|
||||
const sepolia = await fetchTokenBalances(
|
||||
HOLDER,
|
||||
BLOCKSCOUT,
|
||||
[],
|
||||
SEPOLIA,
|
||||
);
|
||||
expect(sepolia).toHaveLength(1);
|
||||
expect(sepolia[0].symbol).toBe("USDC");
|
||||
});
|
||||
|
||||
test("a fake ETH token is filtered on Sepolia too", async () => {
|
||||
respondWith([fakeEthItem()]);
|
||||
expect(
|
||||
await fetchTokenBalances(HOLDER, BLOCKSCOUT, [], SEPOLIA),
|
||||
).toEqual([]);
|
||||
});
|
||||
|
||||
// The trap in this change: the user's real ETH balance is not an ERC-20
|
||||
// and is fetched over RPC in refreshBalances, so it never passes through
|
||||
// this loop at all. An explorer row that is not an ERC-20 is dropped
|
||||
|
||||
@@ -133,13 +133,13 @@ function trackedRow(balance, decimals = null, holders = null) {
|
||||
};
|
||||
}
|
||||
|
||||
async function refresh(addresses, trackedTokens, networkId = "mainnet") {
|
||||
async function refresh(addresses, trackedTokens) {
|
||||
await refreshBalances(
|
||||
[{ addresses }],
|
||||
RPC_URL,
|
||||
EXPLORER_URL,
|
||||
trackedTokens,
|
||||
networkId,
|
||||
"mainnet",
|
||||
new AbortController().signal,
|
||||
);
|
||||
return addresses;
|
||||
@@ -307,104 +307,3 @@ test("a tracked token wearing a known symbol from another contract is not listed
|
||||
);
|
||||
expect(first.tokenBalances).toEqual([]);
|
||||
});
|
||||
|
||||
test("the refresh resolves with each tracked token whose balance it read at every address", async () => {
|
||||
const flaky = "0x9999999999999999999999999999999999999999";
|
||||
holdings[TOKEN] = { [FIRST]: 2000000n, [SECOND]: 0n };
|
||||
// balanceOf answers at FIRST and fails at SECOND.
|
||||
holdings[flaky] = { [FIRST]: 2000000n };
|
||||
const read = await refreshBalances(
|
||||
[
|
||||
{
|
||||
addresses: [
|
||||
{ address: FIRST, tokenBalances: [] },
|
||||
{ address: SECOND, tokenBalances: [] },
|
||||
],
|
||||
},
|
||||
],
|
||||
RPC_URL,
|
||||
EXPLORER_URL,
|
||||
[
|
||||
TRACKED,
|
||||
{ address: flaky, symbol: "FLK", name: "Flaky", decimals: 6 },
|
||||
// A known symbol from another contract: its balance is not read.
|
||||
{ address: OTHER, symbol: "USDC", name: "Fake", decimals: 6 },
|
||||
],
|
||||
"mainnet",
|
||||
new AbortController().signal,
|
||||
);
|
||||
expect(read).toEqual([TOKEN]);
|
||||
});
|
||||
|
||||
// https://git.eeqj.de/sneak/AutistMask/issues/632: the bundled list holds
|
||||
// Ethereum Mainnet contracts. A token outside the tracked tokens with an
|
||||
// unknown holder count is listed only when the bundled list names it.
|
||||
test("an untracked bundled token with an unknown holder count is listed on Ethereum Mainnet only", async () => {
|
||||
explorerRows = [explorerRow(USDC, "USDC", 5000000, null)];
|
||||
const [mainnet] = await refresh(
|
||||
[{ address: FIRST, tokenBalances: [] }],
|
||||
[],
|
||||
);
|
||||
expect(mainnet.tokenBalances).toEqual([
|
||||
{
|
||||
address: USDC,
|
||||
name: "USDC",
|
||||
symbol: "USDC",
|
||||
decimals: 6,
|
||||
balance: "5.0",
|
||||
holders: null,
|
||||
},
|
||||
]);
|
||||
const [sepolia] = await refresh(
|
||||
[{ address: FIRST, tokenBalances: [] }],
|
||||
[],
|
||||
"sepolia",
|
||||
);
|
||||
expect(sepolia.tokenBalances).toEqual([]);
|
||||
});
|
||||
|
||||
test("a tracked token at a bundled token's address takes the bundled scale on Ethereum Mainnet only", async () => {
|
||||
holdings[USDC] = { [FIRST]: 5000000n };
|
||||
// The tracked entry records no decimals, and Blockscout fails.
|
||||
const tracked = [
|
||||
{ address: USDC, symbol: "USDC", name: "USD Coin", decimals: null },
|
||||
];
|
||||
const row = (balance) => ({
|
||||
address: USDC,
|
||||
name: "USD Coin",
|
||||
symbol: "USDC",
|
||||
decimals: null,
|
||||
balance: balance,
|
||||
holders: null,
|
||||
});
|
||||
const [mainnet] = await refresh(
|
||||
[{ address: FIRST, tokenBalances: [] }],
|
||||
tracked,
|
||||
);
|
||||
expect(mainnet.tokenBalances).toEqual([row("5.0")]);
|
||||
const [sepolia] = await refresh(
|
||||
[{ address: FIRST, tokenBalances: [] }],
|
||||
tracked,
|
||||
"sepolia",
|
||||
);
|
||||
expect(sepolia.tokenBalances).toEqual([row(null)]);
|
||||
});
|
||||
|
||||
test("with Sepolia active, a tracked token wearing a bundled symbol from another contract is listed", async () => {
|
||||
holdings[OTHER] = { [FIRST]: 5000000n };
|
||||
const [first] = await refresh(
|
||||
[{ address: FIRST, tokenBalances: [] }],
|
||||
[{ address: OTHER, symbol: "USDC", name: "Other", decimals: 6 }],
|
||||
"sepolia",
|
||||
);
|
||||
expect(first.tokenBalances).toEqual([
|
||||
{
|
||||
address: OTHER,
|
||||
name: "Other",
|
||||
symbol: "USDC",
|
||||
decimals: null,
|
||||
balance: "5.0",
|
||||
holders: null,
|
||||
},
|
||||
]);
|
||||
});
|
||||
|
||||
@@ -5,9 +5,6 @@
|
||||
// a contract lookup that answers after one. Driven through the real popup over
|
||||
// a stored profile; the same switch made by the background is in
|
||||
// tests/coldWorkerChainSwitch.test.js.
|
||||
//
|
||||
// The tests of what another page stored before a switch in Settings cover a
|
||||
// fraud contract too (https://git.eeqj.de/sneak/AutistMask/issues/692).
|
||||
|
||||
const {
|
||||
bootPopup,
|
||||
@@ -117,17 +114,6 @@ async function chooseNetwork(boot, networkId) {
|
||||
await boot.settle();
|
||||
}
|
||||
|
||||
// Adds NEW_TOKEN_ADDRESS by contract address on SettingsAddToken, as the user
|
||||
// does. Returns the record the add tracks.
|
||||
async function addNewToken(boot) {
|
||||
const { lookupTokenInfo } = require("../src/shared/balances");
|
||||
const info = { symbol: "NEW", decimals: 18, name: "New Token" };
|
||||
lookupTokenInfo.mockResolvedValueOnce(info);
|
||||
boot.node("settings-addtoken-address").value = NEW_TOKEN_ADDRESS;
|
||||
await boot.click("btn-settings-addtoken-manual");
|
||||
return { address: NEW_TOKEN_ADDRESS, ...info, balanceNotFetched: true };
|
||||
}
|
||||
|
||||
// The Settings gear, a switch to Sepolia, and Back.
|
||||
async function gearSwitchBack(boot) {
|
||||
await boot.click("btn-settings");
|
||||
@@ -173,9 +159,7 @@ test("a token added by contract address on Sepolia is tracked on Sepolia only",
|
||||
"sepolia",
|
||||
expect.anything(),
|
||||
);
|
||||
// No refresh has read the new token's balance yet.
|
||||
const added = { ...SEPOLIA_TOKEN, balanceNotFetched: true };
|
||||
expect(stored().trackedTokens).toEqual([added]);
|
||||
expect(stored().trackedTokens).toEqual([SEPOLIA_TOKEN]);
|
||||
|
||||
await boot.click("btn-settings");
|
||||
await chooseNetwork(boot, "mainnet");
|
||||
@@ -187,622 +171,12 @@ test("a token added by contract address on Sepolia is tracked on Sepolia only",
|
||||
|
||||
await chooseNetwork(boot, "sepolia");
|
||||
expect(stored().networkId).toBe("sepolia");
|
||||
expect(stored().trackedTokens).toEqual([added]);
|
||||
expect(stored().trackedTokens).toEqual([SEPOLIA_TOKEN]);
|
||||
const onSepolia = boot.node("settings-tracked-tokens").innerHTML;
|
||||
expect(onSepolia).toContain("TST");
|
||||
expect(onSepolia).not.toContain("DAI");
|
||||
});
|
||||
|
||||
// Another popup page tracks DAI on Ethereum Mainnet after this page's last
|
||||
// save. The switch to Sepolia puts DAI away under Ethereum Mainnet.
|
||||
test("a token another page tracked before a switch in Settings stays tracked on Ethereum Mainnet", async () => {
|
||||
const boot = await bootPopup(unversionedValidProfile());
|
||||
expect(boot.pageErrors).toEqual([]);
|
||||
boot.storage.write("autistmask", {
|
||||
...boot.storage.read("autistmask"),
|
||||
trackedTokens: [MAINNET_TOKEN],
|
||||
});
|
||||
|
||||
await boot.click("btn-settings");
|
||||
await chooseNetwork(boot, "sepolia");
|
||||
|
||||
const stored = boot.storage.read("autistmask");
|
||||
expect(stored.networkId).toBe("sepolia");
|
||||
expect(stored.trackedTokens).toEqual([]);
|
||||
expect(stored.networkTrackedTokens.mainnet).toEqual([MAINNET_TOKEN]);
|
||||
});
|
||||
|
||||
// Another popup page stops tracking DAI on Ethereum Mainnet after this page's
|
||||
// last save. This page still holds DAI. The switch to Sepolia does not store
|
||||
// DAI under Ethereum Mainnet again.
|
||||
test("a token another page removed before a switch in Settings stays removed", async () => {
|
||||
const boot = await bootPopup(
|
||||
unversionedValidProfile({ trackedTokens: [MAINNET_TOKEN] }),
|
||||
);
|
||||
expect(boot.pageErrors).toEqual([]);
|
||||
boot.storage.write("autistmask", {
|
||||
...boot.storage.read("autistmask"),
|
||||
trackedTokens: [],
|
||||
});
|
||||
|
||||
await boot.click("btn-settings");
|
||||
await chooseNetwork(boot, "sepolia");
|
||||
|
||||
const stored = boot.storage.read("autistmask");
|
||||
expect(stored.networkId).toBe("sepolia");
|
||||
expect(stored.trackedTokens).toEqual([]);
|
||||
expect(stored.networkTrackedTokens.mainnet).toEqual([]);
|
||||
});
|
||||
|
||||
// Another popup page removes DAI after this page's last save. That page then
|
||||
// adds DAI again, typing the contract address in lower case. The two pages'
|
||||
// entries for DAI match, because contract addresses are compared ignoring
|
||||
// letter case. The switch to Sepolia keeps this page's entry under Ethereum
|
||||
// Mainnet.
|
||||
test("a token another page added again with a lower-case address keeps this page's entry", async () => {
|
||||
const boot = await bootPopup(
|
||||
unversionedValidProfile({ trackedTokens: [MAINNET_TOKEN] }),
|
||||
);
|
||||
expect(boot.pageErrors).toEqual([]);
|
||||
boot.storage.write("autistmask", {
|
||||
...boot.storage.read("autistmask"),
|
||||
trackedTokens: [
|
||||
{ ...MAINNET_TOKEN, address: MAINNET_TOKEN.address.toLowerCase() },
|
||||
],
|
||||
});
|
||||
|
||||
await boot.click("btn-settings");
|
||||
await chooseNetwork(boot, "sepolia");
|
||||
|
||||
const stored = boot.storage.read("autistmask");
|
||||
expect(stored.networkId).toBe("sepolia");
|
||||
expect(stored.networkTrackedTokens.mainnet).toEqual([MAINNET_TOKEN]);
|
||||
});
|
||||
|
||||
// Another popup page saves a switch to Sepolia after this page's last save.
|
||||
// TST is tracked on Sepolia. This page has not taken that switch yet. A switch
|
||||
// to Sepolia in this page's Settings keeps TST off Ethereum Mainnet's list.
|
||||
test("a token tracked on Sepolia when another page switched there is not tracked on Ethereum Mainnet", async () => {
|
||||
const boot = await bootPopup(unversionedValidProfile());
|
||||
expect(boot.pageErrors).toEqual([]);
|
||||
await boot.click("btn-settings");
|
||||
boot.storage.write("autistmask", {
|
||||
...boot.storage.read("autistmask"),
|
||||
networkId: "sepolia",
|
||||
trackedTokens: [SEPOLIA_TOKEN],
|
||||
});
|
||||
|
||||
await chooseNetwork(boot, "sepolia");
|
||||
|
||||
const stored = boot.storage.read("autistmask");
|
||||
expect(stored.networkId).toBe("sepolia");
|
||||
expect(stored.trackedTokens).toEqual([SEPOLIA_TOKEN]);
|
||||
expect(stored.networkTrackedTokens.mainnet).toEqual([]);
|
||||
});
|
||||
|
||||
// Another popup page saves a switch to Sepolia, where TST is tracked. Before
|
||||
// taking that switch, this page adds a token on Ethereum Mainnet. The add's
|
||||
// save adds the token to Ethereum Mainnet's list and leaves Sepolia's list as
|
||||
// it was.
|
||||
test("a token added before this page takes another page's switch is tracked on Ethereum Mainnet", async () => {
|
||||
const boot = await bootOnAddToken("mainnet", {
|
||||
trackedTokens: [MAINNET_TOKEN],
|
||||
networkTrackedTokens: { sepolia: [SEPOLIA_TOKEN] },
|
||||
});
|
||||
expect(boot.pageErrors).toEqual([]);
|
||||
boot.storage.write("autistmask", {
|
||||
...boot.storage.read("autistmask"),
|
||||
networkId: "sepolia",
|
||||
trackedTokens: [SEPOLIA_TOKEN],
|
||||
networkTrackedTokens: {
|
||||
mainnet: [MAINNET_TOKEN],
|
||||
sepolia: [SEPOLIA_TOKEN],
|
||||
},
|
||||
});
|
||||
const { lookupTokenInfo } = require("../src/shared/balances");
|
||||
lookupTokenInfo.mockResolvedValueOnce({
|
||||
symbol: "NEW",
|
||||
decimals: 18,
|
||||
name: "New Token",
|
||||
});
|
||||
|
||||
boot.node("settings-addtoken-address").value = NEW_TOKEN_ADDRESS;
|
||||
await boot.click("btn-settings-addtoken-manual");
|
||||
|
||||
const stored = boot.storage.read("autistmask");
|
||||
expect(stored.networkId).toBe("sepolia");
|
||||
expect(stored.trackedTokens).toEqual([SEPOLIA_TOKEN]);
|
||||
expect(stored.networkTrackedTokens.mainnet).toEqual([
|
||||
MAINNET_TOKEN,
|
||||
{
|
||||
address: NEW_TOKEN_ADDRESS,
|
||||
symbol: "NEW",
|
||||
decimals: 18,
|
||||
name: "New Token",
|
||||
balanceNotFetched: true,
|
||||
},
|
||||
]);
|
||||
});
|
||||
|
||||
// Another popup page tracks DAI on Ethereum Mainnet and then saves a switch to
|
||||
// Sepolia. This page does not track DAI. Before taking that switch, this page
|
||||
// adds a token on Ethereum Mainnet. The add's save puts both DAI and the new
|
||||
// token on Ethereum Mainnet's list.
|
||||
test("a token added before this page takes another page's switch joins that page's tokens on Ethereum Mainnet", async () => {
|
||||
const boot = await bootOnAddToken("mainnet");
|
||||
expect(boot.pageErrors).toEqual([]);
|
||||
boot.storage.write("autistmask", {
|
||||
...boot.storage.read("autistmask"),
|
||||
networkId: "sepolia",
|
||||
trackedTokens: [],
|
||||
networkTrackedTokens: { mainnet: [MAINNET_TOKEN] },
|
||||
});
|
||||
const { lookupTokenInfo } = require("../src/shared/balances");
|
||||
lookupTokenInfo.mockResolvedValueOnce({
|
||||
symbol: "NEW",
|
||||
decimals: 18,
|
||||
name: "New Token",
|
||||
});
|
||||
|
||||
boot.node("settings-addtoken-address").value = NEW_TOKEN_ADDRESS;
|
||||
await boot.click("btn-settings-addtoken-manual");
|
||||
|
||||
const stored = boot.storage.read("autistmask");
|
||||
expect(stored.networkId).toBe("sepolia");
|
||||
expect(stored.trackedTokens).toEqual([]);
|
||||
expect(stored.networkTrackedTokens.mainnet).toEqual([
|
||||
MAINNET_TOKEN,
|
||||
{
|
||||
address: NEW_TOKEN_ADDRESS,
|
||||
symbol: "NEW",
|
||||
decimals: 18,
|
||||
name: "New Token",
|
||||
balanceNotFetched: true,
|
||||
},
|
||||
]);
|
||||
});
|
||||
|
||||
// Another popup page saves a switch to Sepolia, where TST is tracked. Before
|
||||
// taking that switch, this page removes DAI on Ethereum Mainnet, as the `[x]`
|
||||
// on a tracked token in Settings does. The removal's save drops DAI from
|
||||
// Ethereum Mainnet's list and leaves Sepolia's list as it was.
|
||||
test("a token removed before this page takes another page's switch is gone from Ethereum Mainnet", async () => {
|
||||
const boot = await bootPopup(
|
||||
unversionedValidProfile({
|
||||
trackedTokens: [MAINNET_TOKEN],
|
||||
networkTrackedTokens: { sepolia: [SEPOLIA_TOKEN] },
|
||||
}),
|
||||
);
|
||||
expect(boot.pageErrors).toEqual([]);
|
||||
boot.storage.write("autistmask", {
|
||||
...boot.storage.read("autistmask"),
|
||||
networkId: "sepolia",
|
||||
trackedTokens: [SEPOLIA_TOKEN],
|
||||
networkTrackedTokens: {
|
||||
mainnet: [MAINNET_TOKEN],
|
||||
sepolia: [SEPOLIA_TOKEN],
|
||||
},
|
||||
});
|
||||
|
||||
const { state, saveState } = require("../src/shared/state");
|
||||
state.trackedTokens.splice(0, 1);
|
||||
await saveState();
|
||||
|
||||
const stored = boot.storage.read("autistmask");
|
||||
expect(stored.networkId).toBe("sepolia");
|
||||
expect(stored.trackedTokens).toEqual([SEPOLIA_TOKEN]);
|
||||
expect(stored.networkTrackedTokens.mainnet).toEqual([]);
|
||||
});
|
||||
|
||||
// Another popup page tracks DAI on Ethereum Mainnet and then saves a switch to
|
||||
// Sepolia. That switch puts DAI away under Ethereum Mainnet. This page has not
|
||||
// taken the switch yet. A switch to Sepolia in this page's Settings keeps DAI
|
||||
// on Ethereum Mainnet's list.
|
||||
test("a token another page tracked before its own switch stays tracked on Ethereum Mainnet", async () => {
|
||||
const boot = await bootPopup(unversionedValidProfile());
|
||||
expect(boot.pageErrors).toEqual([]);
|
||||
await boot.click("btn-settings");
|
||||
boot.storage.write("autistmask", {
|
||||
...boot.storage.read("autistmask"),
|
||||
networkId: "sepolia",
|
||||
trackedTokens: [],
|
||||
networkTrackedTokens: { mainnet: [MAINNET_TOKEN] },
|
||||
});
|
||||
|
||||
await chooseNetwork(boot, "sepolia");
|
||||
|
||||
const stored = boot.storage.read("autistmask");
|
||||
expect(stored.networkId).toBe("sepolia");
|
||||
expect(stored.networkTrackedTokens.mainnet).toEqual([MAINNET_TOKEN]);
|
||||
});
|
||||
|
||||
// This page switches to Sepolia. Another popup page has not taken that switch,
|
||||
// and its save adds a token to Ethereum Mainnet's list. This page switches back
|
||||
// and tracks that token.
|
||||
test("a token another page added on Ethereum Mainnet is tracked when this page switches back there", async () => {
|
||||
const boot = await bootPopup(
|
||||
unversionedValidProfile({ trackedTokens: [MAINNET_TOKEN] }),
|
||||
);
|
||||
expect(boot.pageErrors).toEqual([]);
|
||||
await boot.click("btn-settings");
|
||||
await chooseNetwork(boot, "sepolia");
|
||||
const newToken = {
|
||||
address: NEW_TOKEN_ADDRESS,
|
||||
symbol: "NEW",
|
||||
decimals: 18,
|
||||
name: "New Token",
|
||||
};
|
||||
boot.storage.write("autistmask", {
|
||||
...boot.storage.read("autistmask"),
|
||||
networkTrackedTokens: { mainnet: [MAINNET_TOKEN, newToken] },
|
||||
});
|
||||
|
||||
await chooseNetwork(boot, "mainnet");
|
||||
|
||||
const stored = boot.storage.read("autistmask");
|
||||
expect(stored.networkId).toBe("mainnet");
|
||||
expect(stored.trackedTokens).toEqual([MAINNET_TOKEN, newToken]);
|
||||
});
|
||||
|
||||
// This page tracks DAI on Ethereum Mainnet and switches to Sepolia. Another
|
||||
// popup page has not taken that switch, and its save removes DAI from Ethereum
|
||||
// Mainnet's list. This page switches back and does not track DAI again.
|
||||
test("a token another page removed on Ethereum Mainnet stays removed when this page switches back there", async () => {
|
||||
const boot = await bootPopup(
|
||||
unversionedValidProfile({ trackedTokens: [MAINNET_TOKEN] }),
|
||||
);
|
||||
expect(boot.pageErrors).toEqual([]);
|
||||
await boot.click("btn-settings");
|
||||
await chooseNetwork(boot, "sepolia");
|
||||
boot.storage.write("autistmask", {
|
||||
...boot.storage.read("autistmask"),
|
||||
networkTrackedTokens: { mainnet: [] },
|
||||
});
|
||||
|
||||
await chooseNetwork(boot, "mainnet");
|
||||
|
||||
const stored = boot.storage.read("autistmask");
|
||||
expect(stored.networkId).toBe("mainnet");
|
||||
expect(stored.trackedTokens).toEqual([]);
|
||||
});
|
||||
|
||||
// Another popup page records a fraud contract on Ethereum Mainnet after this
|
||||
// page's last save. The switch to Sepolia drops that fraud contract, as the
|
||||
// switch drops this page's own.
|
||||
test("a fraud contract another page recorded before a switch in Settings is not kept on Sepolia", async () => {
|
||||
const boot = await bootPopup(unversionedValidProfile());
|
||||
expect(boot.pageErrors).toEqual([]);
|
||||
boot.storage.write("autistmask", {
|
||||
...boot.storage.read("autistmask"),
|
||||
fraudContracts: [NEW_TOKEN_ADDRESS],
|
||||
});
|
||||
|
||||
await boot.click("btn-settings");
|
||||
await chooseNetwork(boot, "sepolia");
|
||||
|
||||
const stored = boot.storage.read("autistmask");
|
||||
expect(stored.networkId).toBe("sepolia");
|
||||
expect(stored.fraudContracts).toEqual([]);
|
||||
});
|
||||
|
||||
// The contract lookup on SettingsAddToken answers on Ethereum Mainnet while the
|
||||
// switch to Sepolia waits for the lock. The page adds the token to Ethereum
|
||||
// Mainnet's list. The switch then keeps that list for Ethereum Mainnet.
|
||||
test("a token added while a switch in Settings waits for the lock stays tracked on Ethereum Mainnet", async () => {
|
||||
const boot = await bootOnAddToken("mainnet");
|
||||
expect(boot.pageErrors).toEqual([]);
|
||||
const { lookupTokenInfo } = require("../src/shared/balances");
|
||||
let answer;
|
||||
lookupTokenInfo.mockImplementationOnce(
|
||||
() =>
|
||||
new Promise((resolve) => {
|
||||
answer = resolve;
|
||||
}),
|
||||
);
|
||||
boot.node("settings-addtoken-address").value = NEW_TOKEN_ADDRESS;
|
||||
const adding = boot.click("btn-settings-addtoken-manual");
|
||||
await boot.click("btn-settings");
|
||||
|
||||
// Another write holds the lock, so the switch's save waits for it.
|
||||
let releaseLock;
|
||||
const lockHeld = navigator.locks.request(
|
||||
"autistmask",
|
||||
() =>
|
||||
new Promise((resolve) => {
|
||||
releaseLock = resolve;
|
||||
}),
|
||||
);
|
||||
const select = boot.node("settings-network");
|
||||
select.value = "sepolia";
|
||||
const switching = Promise.all(select.listeners.change.map((fn) => fn()));
|
||||
await boot.settle();
|
||||
|
||||
answer({ symbol: "NEW", decimals: 18, name: "New Token" });
|
||||
await boot.settle();
|
||||
releaseLock();
|
||||
await lockHeld;
|
||||
await switching;
|
||||
await adding;
|
||||
|
||||
const stored = boot.storage.read("autistmask");
|
||||
expect(stored.networkId).toBe("sepolia");
|
||||
expect(stored.trackedTokens).toEqual([]);
|
||||
expect(stored.networkTrackedTokens.mainnet).toEqual([
|
||||
{
|
||||
address: NEW_TOKEN_ADDRESS,
|
||||
symbol: "NEW",
|
||||
decimals: 18,
|
||||
name: "New Token",
|
||||
balanceNotFetched: true,
|
||||
},
|
||||
]);
|
||||
});
|
||||
|
||||
// The contract lookup on SettingsAddToken answers on Ethereum Mainnet while
|
||||
// this page's switch to Sepolia waits for the lock. Another popup page holds
|
||||
// the lock and stores its own switch to Sepolia, with DAI tracked on Ethereum
|
||||
// Mainnet. This page's switch keeps DAI and the new token on Ethereum Mainnet's
|
||||
// list.
|
||||
test("a token added while a switch in Settings waits for another page's switch stays tracked on Ethereum Mainnet", async () => {
|
||||
const boot = await bootOnAddToken("mainnet");
|
||||
expect(boot.pageErrors).toEqual([]);
|
||||
const { lookupTokenInfo } = require("../src/shared/balances");
|
||||
let answer;
|
||||
lookupTokenInfo.mockImplementationOnce(
|
||||
() =>
|
||||
new Promise((resolve) => {
|
||||
answer = resolve;
|
||||
}),
|
||||
);
|
||||
boot.node("settings-addtoken-address").value = NEW_TOKEN_ADDRESS;
|
||||
const adding = boot.click("btn-settings-addtoken-manual");
|
||||
await boot.click("btn-settings");
|
||||
|
||||
let releaseLock;
|
||||
const lockHeld = navigator.locks.request(
|
||||
"autistmask",
|
||||
() =>
|
||||
new Promise((resolve) => {
|
||||
releaseLock = resolve;
|
||||
}),
|
||||
);
|
||||
const select = boot.node("settings-network");
|
||||
select.value = "sepolia";
|
||||
const switching = Promise.all(select.listeners.change.map((fn) => fn()));
|
||||
await boot.settle();
|
||||
boot.storage.write("autistmask", {
|
||||
...boot.storage.read("autistmask"),
|
||||
networkId: "sepolia",
|
||||
trackedTokens: [],
|
||||
networkTrackedTokens: { mainnet: [MAINNET_TOKEN] },
|
||||
});
|
||||
|
||||
answer({ symbol: "NEW", decimals: 18, name: "New Token" });
|
||||
await boot.settle();
|
||||
releaseLock();
|
||||
await lockHeld;
|
||||
await switching;
|
||||
await adding;
|
||||
|
||||
const stored = boot.storage.read("autistmask");
|
||||
expect(stored.networkId).toBe("sepolia");
|
||||
expect(stored.trackedTokens).toEqual([]);
|
||||
expect(stored.networkTrackedTokens.mainnet).toEqual([
|
||||
MAINNET_TOKEN,
|
||||
{
|
||||
address: NEW_TOKEN_ADDRESS,
|
||||
symbol: "NEW",
|
||||
decimals: 18,
|
||||
name: "New Token",
|
||||
balanceNotFetched: true,
|
||||
},
|
||||
]);
|
||||
});
|
||||
|
||||
// Another popup page holds the lock and stores its switch to Sepolia, with DAI
|
||||
// tracked on Ethereum Mainnet. This page waits for the lock to take that
|
||||
// switch. Meanwhile, the contract lookup on SettingsAddToken answers on
|
||||
// Ethereum Mainnet. When this page takes that switch, DAI and the new token
|
||||
// stay on Ethereum Mainnet's list.
|
||||
test("a token added while this page waits to take another page's switch stays tracked on Ethereum Mainnet", async () => {
|
||||
const boot = await bootOnAddToken("mainnet");
|
||||
expect(boot.pageErrors).toEqual([]);
|
||||
let releaseLock;
|
||||
const lockHeld = navigator.locks.request(
|
||||
"autistmask",
|
||||
() =>
|
||||
new Promise((resolve) => {
|
||||
releaseLock = resolve;
|
||||
}),
|
||||
);
|
||||
await boot.storage.local.set({
|
||||
autistmask: {
|
||||
...boot.storage.read("autistmask"),
|
||||
networkId: "sepolia",
|
||||
trackedTokens: [],
|
||||
networkTrackedTokens: { mainnet: [MAINNET_TOKEN] },
|
||||
},
|
||||
});
|
||||
await boot.settle();
|
||||
const { lookupTokenInfo } = require("../src/shared/balances");
|
||||
lookupTokenInfo.mockResolvedValueOnce({
|
||||
symbol: "NEW",
|
||||
decimals: 18,
|
||||
name: "New Token",
|
||||
});
|
||||
|
||||
boot.node("settings-addtoken-address").value = NEW_TOKEN_ADDRESS;
|
||||
const adding = boot.click("btn-settings-addtoken-manual");
|
||||
await boot.settle();
|
||||
releaseLock();
|
||||
await lockHeld;
|
||||
await adding;
|
||||
await boot.settle();
|
||||
|
||||
const stored = boot.storage.read("autistmask");
|
||||
expect(stored.networkId).toBe("sepolia");
|
||||
expect(stored.trackedTokens).toEqual([]);
|
||||
expect(stored.networkTrackedTokens.mainnet).toEqual([
|
||||
MAINNET_TOKEN,
|
||||
{
|
||||
address: NEW_TOKEN_ADDRESS,
|
||||
symbol: "NEW",
|
||||
decimals: 18,
|
||||
name: "New Token",
|
||||
balanceNotFetched: true,
|
||||
},
|
||||
]);
|
||||
});
|
||||
|
||||
// This page tracks DAI on Ethereum Mainnet. Another popup page holds the lock
|
||||
// and stores its switch to Sepolia, with DAI on Ethereum Mainnet's list. This
|
||||
// page waits for the lock to take that switch. Meanwhile, the user removes DAI,
|
||||
// as the `[x]` on a tracked token in Settings does. When this page takes that
|
||||
// switch, DAI is gone from Ethereum Mainnet's list.
|
||||
test("a token removed while this page waits to take another page's switch is gone from Ethereum Mainnet", async () => {
|
||||
const boot = await bootPopup(
|
||||
unversionedValidProfile({ trackedTokens: [MAINNET_TOKEN] }),
|
||||
);
|
||||
expect(boot.pageErrors).toEqual([]);
|
||||
let releaseLock;
|
||||
const lockHeld = navigator.locks.request(
|
||||
"autistmask",
|
||||
() =>
|
||||
new Promise((resolve) => {
|
||||
releaseLock = resolve;
|
||||
}),
|
||||
);
|
||||
await boot.storage.local.set({
|
||||
autistmask: {
|
||||
...boot.storage.read("autistmask"),
|
||||
networkId: "sepolia",
|
||||
trackedTokens: [],
|
||||
networkTrackedTokens: { mainnet: [MAINNET_TOKEN] },
|
||||
},
|
||||
});
|
||||
await boot.settle();
|
||||
|
||||
const { state, saveState } = require("../src/shared/state");
|
||||
state.trackedTokens.splice(0, 1);
|
||||
const removing = saveState();
|
||||
releaseLock();
|
||||
await lockHeld;
|
||||
await removing;
|
||||
await boot.settle();
|
||||
|
||||
const stored = boot.storage.read("autistmask");
|
||||
expect(stored.networkId).toBe("sepolia");
|
||||
expect(stored.trackedTokens).toEqual([]);
|
||||
expect(stored.networkTrackedTokens.mainnet).toEqual([]);
|
||||
});
|
||||
|
||||
// Another popup page tracks DAI after this page's last save. This page then
|
||||
// adds a token. Its save keeps DAI.
|
||||
test("a token another page added stays when this page adds a token", async () => {
|
||||
const boot = await bootOnAddToken("mainnet");
|
||||
expect(boot.pageErrors).toEqual([]);
|
||||
boot.storage.write("autistmask", {
|
||||
...boot.storage.read("autistmask"),
|
||||
trackedTokens: [MAINNET_TOKEN],
|
||||
});
|
||||
|
||||
const added = await addNewToken(boot);
|
||||
|
||||
expect(boot.storage.read("autistmask").trackedTokens).toEqual([
|
||||
MAINNET_TOKEN,
|
||||
added,
|
||||
]);
|
||||
});
|
||||
|
||||
// Another popup page tracks a new token after this page's last save. This page
|
||||
// then removes DAI, as the `[x]` on a tracked token in Settings does. Its save
|
||||
// keeps the new token.
|
||||
test("a token another page added stays when this page removes a token", async () => {
|
||||
const boot = await bootPopup(
|
||||
unversionedValidProfile({ trackedTokens: [MAINNET_TOKEN] }),
|
||||
);
|
||||
expect(boot.pageErrors).toEqual([]);
|
||||
const otherPageToken = {
|
||||
address: NEW_TOKEN_ADDRESS,
|
||||
symbol: "NEW",
|
||||
decimals: 18,
|
||||
name: "New Token",
|
||||
};
|
||||
boot.storage.write("autistmask", {
|
||||
...boot.storage.read("autistmask"),
|
||||
trackedTokens: [MAINNET_TOKEN, otherPageToken],
|
||||
});
|
||||
|
||||
const { state, saveState } = require("../src/shared/state");
|
||||
state.trackedTokens.splice(0, 1);
|
||||
await saveState();
|
||||
|
||||
expect(boot.storage.read("autistmask").trackedTokens).toEqual([
|
||||
otherPageToken,
|
||||
]);
|
||||
});
|
||||
|
||||
// Another popup page stops tracking DAI after this page's last save. This page
|
||||
// still holds DAI and adds a token. Its save does not store DAI again.
|
||||
test("a token another page removed stays removed when this page adds a token", async () => {
|
||||
const boot = await bootOnAddToken("mainnet", {
|
||||
trackedTokens: [MAINNET_TOKEN],
|
||||
});
|
||||
expect(boot.pageErrors).toEqual([]);
|
||||
boot.storage.write("autistmask", {
|
||||
...boot.storage.read("autistmask"),
|
||||
trackedTokens: [],
|
||||
});
|
||||
|
||||
const added = await addNewToken(boot);
|
||||
|
||||
expect(boot.storage.read("autistmask").trackedTokens).toEqual([added]);
|
||||
});
|
||||
|
||||
// Another popup page tracks DAI and the new token after this page's last save,
|
||||
// and its refresh has read the new token's balance. This page adds the new token
|
||||
// too, so the two pages hold different records for it. The save stores one
|
||||
// record for the new token, this page's, and keeps DAI.
|
||||
test("a token both pages added is stored once, with this page's record", async () => {
|
||||
const boot = await bootOnAddToken("mainnet");
|
||||
expect(boot.pageErrors).toEqual([]);
|
||||
boot.storage.write("autistmask", {
|
||||
...boot.storage.read("autistmask"),
|
||||
trackedTokens: [
|
||||
MAINNET_TOKEN,
|
||||
{
|
||||
address: NEW_TOKEN_ADDRESS,
|
||||
symbol: "NEW",
|
||||
decimals: 18,
|
||||
name: "New Token",
|
||||
},
|
||||
],
|
||||
});
|
||||
|
||||
const added = await addNewToken(boot);
|
||||
|
||||
expect(boot.storage.read("autistmask").trackedTokens).toEqual([
|
||||
MAINNET_TOKEN,
|
||||
added,
|
||||
]);
|
||||
});
|
||||
|
||||
// This page and the stored list each hold DAI twice. This page then adds a
|
||||
// token. Its save stores DAI once.
|
||||
test("a token held twice is stored once when this page adds a token", async () => {
|
||||
const boot = await bootOnAddToken("mainnet", {
|
||||
trackedTokens: [MAINNET_TOKEN, MAINNET_TOKEN],
|
||||
});
|
||||
expect(boot.pageErrors).toEqual([]);
|
||||
|
||||
const added = await addNewToken(boot);
|
||||
|
||||
expect(boot.storage.read("autistmask").trackedTokens).toEqual([
|
||||
MAINNET_TOKEN,
|
||||
added,
|
||||
]);
|
||||
});
|
||||
|
||||
describe("Back after a switch from the Settings gear", () => {
|
||||
test("SettingsAddToken no longer offers the common tokens", async () => {
|
||||
const boot = await bootOnAddToken("mainnet");
|
||||
|
||||
@@ -1,202 +0,0 @@
|
||||
// TransactionDetail shows only details that Blockscout gave for the
|
||||
// transaction on screen (https://git.eeqj.de/sneak/AutistMask/issues/675).
|
||||
//
|
||||
// The screen asks Blockscout for its transaction and does not wait for the
|
||||
// answer. So the user can press Back and open another transaction before
|
||||
// Blockscout answers for the first. The first answer must then fill nothing on
|
||||
// the second transaction's screen. An answer that lands while Settings is up
|
||||
// must still fill TransactionDetail.
|
||||
//
|
||||
// Driven through the real popup over a stored profile
|
||||
// (tests/support/popupBoot.js). Each transaction is opened as a history screen
|
||||
// opens it: the current screen is pushed, then transactionDetail.show() draws
|
||||
// the transaction.
|
||||
|
||||
"use strict";
|
||||
|
||||
const {
|
||||
bootPopup,
|
||||
cleanupPopup,
|
||||
unversionedValidProfile,
|
||||
ADDRESS,
|
||||
} = require("./support/popupBoot");
|
||||
|
||||
const MAINNET_BLOCKSCOUT = "https://eth.blockscout.com/api/v2";
|
||||
const SEPOLIA_BLOCKSCOUT = "https://eth-sepolia.blockscout.com/api/v2";
|
||||
const RECIPIENT = "0x2222222222222222222222222222222222222222";
|
||||
|
||||
// A history entry for a send of 1 `symbol` from ADDRESS to RECIPIENT, on the
|
||||
// network with `chainId`.
|
||||
function historyEntry(hash, chainId, symbol) {
|
||||
return {
|
||||
hash,
|
||||
from: ADDRESS,
|
||||
to: RECIPIENT,
|
||||
value: "1.0000",
|
||||
exactValue: "1.0",
|
||||
symbol,
|
||||
timestamp: 1790000000,
|
||||
isError: false,
|
||||
direction: "sent",
|
||||
directionLabel: "Sent",
|
||||
contractAddress: null,
|
||||
chainId,
|
||||
};
|
||||
}
|
||||
|
||||
const FIRST = historyEntry("0x" + "aa".repeat(32), "0x1", "ETH");
|
||||
const SECOND = historyEntry("0x" + "bb".repeat(32), "0x1", "ETH");
|
||||
// A transaction on Sepolia with the same hash as FIRST.
|
||||
const FIRST_ON_SEPOLIA = historyEntry(FIRST.hash, "0xaa36a7", "SepoliaETH");
|
||||
|
||||
// The URL that asks Blockscout for `entry`, on the network it was sent on.
|
||||
function requestUrl(entry) {
|
||||
const blockscout =
|
||||
entry.chainId === "0x1" ? MAINNET_BLOCKSCOUT : SEPOLIA_BLOCKSCOUT;
|
||||
return blockscout + "/transactions/" + entry.hash;
|
||||
}
|
||||
|
||||
// What Blockscout reports for each transaction, by the URL that asks for it.
|
||||
const ANSWERS = {
|
||||
[requestUrl(FIRST)]: {
|
||||
block_number: 21000001,
|
||||
nonce: 4441,
|
||||
fee: { value: "21000000000000" },
|
||||
raw_input: "0x11111111",
|
||||
method: "firstMethod",
|
||||
},
|
||||
[requestUrl(SECOND)]: {
|
||||
block_number: 21000002,
|
||||
nonce: 4442,
|
||||
fee: { value: "42000000000000" },
|
||||
raw_input: "0x22222222",
|
||||
method: "secondMethod",
|
||||
},
|
||||
[requestUrl(FIRST_ON_SEPOLIA)]: {
|
||||
block_number: 21000003,
|
||||
nonce: 4443,
|
||||
fee: { value: "63000000000000" },
|
||||
raw_input: "0x33333333",
|
||||
method: "sepoliaMethod",
|
||||
},
|
||||
};
|
||||
|
||||
// The text each answer puts on screen: its block, nonce, fee, method name and
|
||||
// raw data. No text from one answer appears in another.
|
||||
const FIRST_SHOWN = [
|
||||
"21000001",
|
||||
"4441",
|
||||
"0.000021 ETH",
|
||||
"firstMethod",
|
||||
"0x11111111",
|
||||
];
|
||||
const SECOND_SHOWN = [
|
||||
"21000002",
|
||||
"4442",
|
||||
"0.000042 ETH",
|
||||
"secondMethod",
|
||||
"0x22222222",
|
||||
];
|
||||
const FIRST_ON_SEPOLIA_SHOWN = [
|
||||
"21000003",
|
||||
"4443",
|
||||
"0.000063 SepoliaETH",
|
||||
"sepoliaMethod",
|
||||
"0x33333333",
|
||||
];
|
||||
|
||||
// Everything drawn in the fields that Blockscout's answer fills.
|
||||
function drawnDetails(page) {
|
||||
return [
|
||||
"tx-detail-block",
|
||||
"tx-detail-nonce",
|
||||
"tx-detail-fee",
|
||||
"tx-detail-calldata-action",
|
||||
"tx-detail-rawdata",
|
||||
]
|
||||
.map((id) => page.node(id).innerHTML + page.node(id).textContent)
|
||||
.join("\n");
|
||||
}
|
||||
|
||||
// Opens `entry` on TransactionDetail, as a history screen does.
|
||||
function open(entry) {
|
||||
require("../src/popup/views/helpers").pushCurrentView();
|
||||
require("../src/popup/views/transactionDetail").show(entry);
|
||||
}
|
||||
|
||||
// The URLs of every request to Blockscout so far, in order.
|
||||
function requestedUrls() {
|
||||
return globalThis.fetch.mock.calls.map(([url]) => url);
|
||||
}
|
||||
|
||||
// Boots the popup on Home with "Use Blockscout" on. Blockscout answers every
|
||||
// request at once from ANSWERS, except the request for `held`. Returns the
|
||||
// page and answer(), which lets the answer for `held` land.
|
||||
async function bootWithHeldRequest(held) {
|
||||
const page = await bootPopup(
|
||||
unversionedValidProfile({ useBlockscout: true }),
|
||||
);
|
||||
let answer;
|
||||
const heldAnswer = new Promise((resolve) => {
|
||||
answer = resolve;
|
||||
});
|
||||
globalThis.fetch = jest.fn(async (url) => {
|
||||
if (url === requestUrl(held)) await heldAnswer;
|
||||
return { ok: true, status: 200, json: async () => ANSWERS[url] };
|
||||
});
|
||||
return { page, answer: () => answer() };
|
||||
}
|
||||
|
||||
// The user opens `first`, whose request to Blockscout is held. Then the user
|
||||
// presses Back and opens `second`. Then the answer for `first` lands. Returns
|
||||
// the page.
|
||||
async function firstAnswerLandsOnSecond(first, second) {
|
||||
const { page, answer } = await bootWithHeldRequest(first);
|
||||
open(first);
|
||||
await page.settle();
|
||||
await page.click("btn-tx-back");
|
||||
expect(page.visibleViews()).toEqual(["main"]);
|
||||
open(second);
|
||||
await page.settle();
|
||||
expect(requestedUrls()).toEqual([requestUrl(first), requestUrl(second)]);
|
||||
answer();
|
||||
await page.settle();
|
||||
expect(page.visibleViews()).toEqual(["transaction"]);
|
||||
return page;
|
||||
}
|
||||
|
||||
afterEach(() => {
|
||||
cleanupPopup();
|
||||
});
|
||||
|
||||
test("an answer for the first transaction that lands on the second one's screen fills nothing", async () => {
|
||||
const page = await firstAnswerLandsOnSecond(FIRST, SECOND);
|
||||
|
||||
const drawn = drawnDetails(page);
|
||||
for (const text of SECOND_SHOWN) expect(drawn).toContain(text);
|
||||
for (const text of FIRST_SHOWN) expect(drawn).not.toContain(text);
|
||||
});
|
||||
|
||||
test("an answer for a hash on mainnet that lands on the same hash's screen on Sepolia fills nothing", async () => {
|
||||
const page = await firstAnswerLandsOnSecond(FIRST, FIRST_ON_SEPOLIA);
|
||||
|
||||
const drawn = drawnDetails(page);
|
||||
for (const text of FIRST_ON_SEPOLIA_SHOWN) expect(drawn).toContain(text);
|
||||
for (const text of FIRST_SHOWN) expect(drawn).not.toContain(text);
|
||||
});
|
||||
|
||||
test("an answer that lands while Settings is up still fills TransactionDetail", async () => {
|
||||
const { page, answer } = await bootWithHeldRequest(FIRST);
|
||||
open(FIRST);
|
||||
await page.settle();
|
||||
await page.click("btn-settings");
|
||||
expect(page.visibleViews()).toEqual(["settings"]);
|
||||
answer();
|
||||
await page.settle();
|
||||
await page.click("btn-settings");
|
||||
|
||||
expect(page.visibleViews()).toEqual(["transaction"]);
|
||||
expect(requestedUrls()).toEqual([requestUrl(FIRST)]);
|
||||
const drawn = drawnDetails(page);
|
||||
for (const text of FIRST_SHOWN) expect(drawn).toContain(text);
|
||||
});
|
||||
@@ -144,7 +144,6 @@ function tokenTx(overrides = {}) {
|
||||
isError: false,
|
||||
contractAddress: USDC_CONTRACT,
|
||||
holders: 3500000,
|
||||
chainId: "0x1",
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
@@ -260,32 +259,6 @@ describe("known-symbol spoof verification", () => {
|
||||
expect(result.newFraudContracts).toEqual([NOVEL_SPAM_CONTRACT]);
|
||||
});
|
||||
|
||||
// https://git.eeqj.de/sneak/AutistMask/issues/632: the bundled list holds
|
||||
// mainnet contracts, so its symbols are not known symbols on Sepolia.
|
||||
test("on Sepolia, a bundled symbol from another contract is kept", () => {
|
||||
const sepoliaToken = tokenTx({
|
||||
symbol: "USDC",
|
||||
contractAddress: NOVEL_SPAM_CONTRACT,
|
||||
holders: 5000000,
|
||||
chainId: "0xaa36a7",
|
||||
});
|
||||
const result = filterTransactions([sepoliaToken], filters());
|
||||
expect(result.transactions).toEqual([sepoliaToken]);
|
||||
expect(result.newFraudContracts).toEqual([]);
|
||||
});
|
||||
|
||||
test('on Sepolia, "ETH" as an ERC-20 is still spoofed', () => {
|
||||
const fakeEth = tokenTx({
|
||||
symbol: "ETH",
|
||||
contractAddress: NOVEL_SPAM_CONTRACT,
|
||||
holders: 5000000,
|
||||
chainId: "0xaa36a7",
|
||||
});
|
||||
expect(filterTransactions([fakeEth], filters()).transactions).toEqual(
|
||||
[],
|
||||
);
|
||||
});
|
||||
|
||||
test("the genuine contract for that symbol is not spoofed", () => {
|
||||
const genuine = tokenTx();
|
||||
const result = filterTransactions([genuine], filters());
|
||||
@@ -1522,41 +1495,6 @@ describe("fetchRecentTransactions merge and dedup", () => {
|
||||
expect(mainnet[0].chainId).toBe("0x1");
|
||||
});
|
||||
|
||||
// https://git.eeqj.de/sneak/AutistMask/issues/632: the bundled token list
|
||||
// names a contract only on Ethereum Mainnet. On Sepolia, a call to the
|
||||
// contract at USDC's mainnet address is labelled with the network's native
|
||||
// currency. A call to any contract the wallet does not name gets that label.
|
||||
test("a contract call on Sepolia is not named by the bundled list", async () => {
|
||||
respondWith(
|
||||
[
|
||||
{
|
||||
hash: "0x" + "b".repeat(64),
|
||||
block_number: 21000095,
|
||||
timestamp: TS,
|
||||
from: { hash: VICTIM },
|
||||
to: { hash: USDC_CONTRACT, is_contract: true },
|
||||
value: "0",
|
||||
method: "approve",
|
||||
status: "ok",
|
||||
},
|
||||
],
|
||||
[],
|
||||
);
|
||||
const sepolia = await fetchRecentTransactions(
|
||||
VICTIM,
|
||||
BLOCKSCOUT,
|
||||
"0xaa36a7",
|
||||
);
|
||||
expect(sepolia[0].directionLabel).toBe("Approve");
|
||||
expect(sepolia[0].symbol).toBe("SepoliaETH");
|
||||
const mainnet = await fetchRecentTransactions(
|
||||
VICTIM,
|
||||
BLOCKSCOUT,
|
||||
"0x1",
|
||||
);
|
||||
expect(mainnet[0].symbol).toBe("USDC");
|
||||
});
|
||||
|
||||
test("the fake token transfer survives fetching and is then filtered", async () => {
|
||||
respondWith(
|
||||
[],
|
||||
|
||||
+85
-855
File diff suppressed because it is too large
Load Diff
@@ -688,62 +688,6 @@ describe("an UNWRAP_WETH makes the output ETH only when the router holds it", ()
|
||||
]);
|
||||
});
|
||||
|
||||
// The same route, then a balance check of the sender's USDC with a zero
|
||||
// minimum. The check guarantees nothing, so Token Out stays ETH
|
||||
// (https://git.eeqj.de/sneak/AutistMask/issues/649).
|
||||
test("the same route, then a zero balance check of USDC, still reads as ETH with no minimum", () => {
|
||||
const result = decode(
|
||||
execute(
|
||||
v4Swap(
|
||||
SWAP_USDT_FOR_WETH,
|
||||
SETTLE_USDT,
|
||||
take(WETH, MSG_SENDER, (ONE_WETH * 6n) / 10n),
|
||||
take(WETH, ADDRESS_THIS),
|
||||
),
|
||||
unwrapWeth(MSG_SENDER),
|
||||
balanceCheck(USDC, 0n),
|
||||
),
|
||||
);
|
||||
expect(result.name).toBe("Swap USDT → ETH");
|
||||
expect(detail(result, "Token Out").value).toBe("ETH");
|
||||
expect(labels(result)).toEqual([
|
||||
"Protocol",
|
||||
"Token In",
|
||||
"Amount",
|
||||
"Token Out",
|
||||
"Steps",
|
||||
"Deadline",
|
||||
]);
|
||||
});
|
||||
|
||||
// A PERMIT2_TRANSFER_FROM moves the sender's WETH into the router. An
|
||||
// UNWRAP_WETH pays that WETH to the user as ETH. A zero balance check of
|
||||
// USDC sets neither Token Out nor the minimum, before the UNWRAP_WETH or
|
||||
// after it (https://git.eeqj.de/sneak/AutistMask/issues/649).
|
||||
test.each([
|
||||
{
|
||||
kind: "before the UNWRAP_WETH",
|
||||
steps: [balanceCheck(USDC, 0n), unwrapWeth(MSG_SENDER)],
|
||||
},
|
||||
{
|
||||
kind: "after the UNWRAP_WETH",
|
||||
steps: [unwrapWeth(MSG_SENDER), balanceCheck(USDC, 0n)],
|
||||
},
|
||||
])(
|
||||
"WETH moved into the router and unwrapped, with a zero balance check of USDC $kind, reads as ETH with no minimum",
|
||||
({ steps }) => {
|
||||
const result = decode(
|
||||
execute(
|
||||
permit2TransferFrom(WETH, ADDRESS_THIS, ONE_WETH),
|
||||
...steps,
|
||||
),
|
||||
);
|
||||
expect(detail(result, "Token Out").value).toBe("ETH");
|
||||
expect(detail(result, "Min. received")).toBeUndefined();
|
||||
expect(detail(result, "Min. paid out")).toBeUndefined();
|
||||
},
|
||||
);
|
||||
|
||||
// A TAKE the decoder cannot read may pay part of the WETH to the user.
|
||||
test("one V4 step paying WETH to the router beside a TAKE that cannot be read, then an UNWRAP_WETH, reads as ETH with no minimum", () => {
|
||||
const result = decode(
|
||||
@@ -1717,18 +1661,9 @@ describe("any token left in the router is not received", () => {
|
||||
),
|
||||
min: "1990.0000 USDC",
|
||||
},
|
||||
])("$kind reads as a swap paid to the user", ({ data, min }) => {
|
||||
const result = decode(data);
|
||||
expect(labels(result)).toEqual(PAID_TO_USER);
|
||||
expect(detail(result, "Min. received").value).toBe(min);
|
||||
});
|
||||
|
||||
// https://git.eeqj.de/sneak/AutistMask/issues/682 — the SETTLE spends all
|
||||
// the router's ETH, the transaction's value included, so the sender pays
|
||||
// an amount the calldata does not state.
|
||||
test("a swap paying WETH to the router, an UNWRAP_WETH into the router, then a V4 swap settling all the ETH from the router reads as a swap paid to the user", () => {
|
||||
const result = decode(
|
||||
execute(
|
||||
{
|
||||
kind: "a swap paying WETH to the router, an UNWRAP_WETH into the router, then a V4 swap settling all the ETH from the router",
|
||||
data: execute(
|
||||
swapToWeth(ADDRESS_THIS),
|
||||
unwrapWeth(ADDRESS_THIS),
|
||||
v4Swap(
|
||||
@@ -1737,23 +1672,12 @@ describe("any token left in the router is not received", () => {
|
||||
takeAll(USDC),
|
||||
),
|
||||
),
|
||||
);
|
||||
expect(labels(result)).toEqual([
|
||||
"Protocol",
|
||||
"Token In",
|
||||
"Amount",
|
||||
"Moved from the sender",
|
||||
"Token moved",
|
||||
"Moved to",
|
||||
"Token Out",
|
||||
"Min. received",
|
||||
"Steps",
|
||||
"Deadline",
|
||||
]);
|
||||
expect(detail(result, "Moved from the sender").value).toBe(
|
||||
"Unknown (could not be decoded)",
|
||||
);
|
||||
expect(detail(result, "Min. received").value).toBe("1990.0000 USDC");
|
||||
min: "1990.0000 USDC",
|
||||
},
|
||||
])("$kind reads as a swap paid to the user", ({ data, min }) => {
|
||||
const result = decode(data);
|
||||
expect(labels(result)).toEqual(PAID_TO_USER);
|
||||
expect(detail(result, "Min. received").value).toBe(min);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -2876,16 +2800,17 @@ describe("the allow-revert flag", () => {
|
||||
},
|
||||
);
|
||||
|
||||
test("a BALANCE_CHECK_ERC20 with the flag, and no minimum before it, names no output token and no minimum", () => {
|
||||
test("a BALANCE_CHECK_ERC20 with the flag, and no minimum before it, states none", () => {
|
||||
const check = balanceCheck(WETH, ONE_WETH);
|
||||
expect(detail(decode(execute(check)), "Min. paid out").value).toBe(
|
||||
"1.0000 WETH",
|
||||
);
|
||||
|
||||
const withFlag = decode(execute(flagged(check)));
|
||||
expect(detail(withFlag, "Token Out").value).toBe(UNNAMED);
|
||||
expect(detail(withFlag, "Min. paid out")).toBeUndefined();
|
||||
expect(detail(withFlag, "Min. received")).toBeUndefined();
|
||||
expect(detail(withFlag, "Token Out").address).toBe(WETH);
|
||||
expect(detail(withFlag, "Min. paid out").value).toBe(
|
||||
"None (no minimum guaranteed)",
|
||||
);
|
||||
});
|
||||
|
||||
// Only the routers from UniversalRouterV2 on let a PERMIT2_PERMIT fail.
|
||||
|
||||
@@ -103,7 +103,7 @@ describe("balanceLine", () => {
|
||||
});
|
||||
|
||||
test("an unknown quantity produces no fiat figure, a zero one does", () => {
|
||||
prices[NOVEL] = 3;
|
||||
prices.NOVEL = 3;
|
||||
const unknown = balanceLine("NOVEL", null, 3, NOVEL);
|
||||
const zero = balanceLine("NOVEL", 0, 3, NOVEL);
|
||||
// A price times an unknown quantity is not $0.00: that is the same
|
||||
@@ -162,7 +162,7 @@ describe("getAddressValue", () => {
|
||||
// make it incomplete.
|
||||
test("an unknown balance makes the total partial, a zero balance does not", () => {
|
||||
prices.ETH = 2000;
|
||||
prices[NOVEL] = 3;
|
||||
prices.NOVEL = 3;
|
||||
const unknown = getAddressValue(address(null));
|
||||
const zero = getAddressValue(address("0.0"));
|
||||
expect(unknown).not.toEqual(zero);
|
||||
@@ -172,7 +172,7 @@ describe("getAddressValue", () => {
|
||||
|
||||
test("an unknown balance is not priced as zero of the token", () => {
|
||||
prices.ETH = 2000;
|
||||
prices[NOVEL] = 3;
|
||||
prices.NOVEL = 3;
|
||||
// The same row with a real quantity of 10 is worth $30. Neither that
|
||||
// figure nor a confident $0.00 may be stated for the unknown one.
|
||||
expect(getAddressValue(address("10.0"))).toEqual({
|
||||
|
||||
@@ -167,8 +167,7 @@ function row(token = {}, value = FIVE_WETH) {
|
||||
}
|
||||
|
||||
// Fetch the explorer's rows through the real fetcher and put them exactly where
|
||||
// refreshBalances() puts them on Ethereum Mainnet. The node reports the holding
|
||||
// the explorer does.
|
||||
// refreshBalances() puts them. The node reports the holding the explorer does.
|
||||
async function fetchOnto(items) {
|
||||
mockProvider.tokenUnits = BigInt(items[0].value);
|
||||
debugFetch.mockImplementation(async () => ({
|
||||
@@ -177,7 +176,7 @@ async function fetchOnto(items) {
|
||||
statusText: "OK",
|
||||
json: async () => items,
|
||||
}));
|
||||
const balances = await fetchTokenBalances(HOLDER, BLOCKSCOUT, [], "0x1");
|
||||
const balances = await fetchTokenBalances(HOLDER, BLOCKSCOUT, []);
|
||||
state.wallets = [
|
||||
{
|
||||
name: "Wallet 1",
|
||||
|
||||
@@ -357,11 +357,6 @@ describe("every way to a signature or the private key refuses a defective wallet
|
||||
});
|
||||
|
||||
beforeEach(() => {
|
||||
// showFlash() starts a timer that clears the message two seconds
|
||||
// later. Each test here runs on fake timers and drops them in
|
||||
// afterEach, so that timer never outlives the test.
|
||||
jest.useFakeTimers();
|
||||
|
||||
const broken = brokenXprvWallet();
|
||||
// A balance, so that no Send button's zero-balance refusal can stand
|
||||
// in for the defect check.
|
||||
@@ -403,7 +398,6 @@ describe("every way to a signature or the private key refuses a defective wallet
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
jest.useRealTimers();
|
||||
state.wallets = [];
|
||||
state.activeAddress = null;
|
||||
state.selectedWallet = null;
|
||||
|
||||
Reference in New Issue
Block a user