Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
 sneak
|
1e8691a3f6 |
@@ -905,8 +905,8 @@ src/
|
||||
prices.js — ETH/USD and token/USD from Chainlink price feeds
|
||||
scamlist.js — known fraud contract addresses
|
||||
state.js — persisted state (extension storage)
|
||||
storedSettings.js — "Use Blockscout", "Check recipients on Etherscan" and
|
||||
the active network, read from storage
|
||||
storedSettings.js — "Use Blockscout" and "Check recipients on Etherscan",
|
||||
read from storage for the requests those settings gate
|
||||
symbolSpoof.js — the known-symbol spoof rule, shared by all surfaces
|
||||
tokenList.js — top ERC-20 tokens by market cap, and their Chainlink
|
||||
price feeds (hardcoded)
|
||||
@@ -1266,7 +1266,8 @@ see Transaction Decoding), do not always read as a number. They can read:
|
||||
the same words. `Unlimited`, `All available (V4 open delta)` and
|
||||
`Whatever an earlier step sent to the pair (V2 already paid)` keep their
|
||||
wording. When a V2 or V3 exact-out step sets `Min. received`, that line shows
|
||||
its `amountOut`, the exact amount it buys.
|
||||
its `amountOut`, the exact amount it buys. When earlier swap steps also pay
|
||||
that token to the user, the line shows the sum (see Transaction Decoding).
|
||||
- `All available (V4 open delta)`: the swap's `Amount` line, when the amount it
|
||||
shows is a V4 exact-in `amountIn` of zero. V4 reads that zero as "use the
|
||||
whole open delta", so the calldata states no quantity. Transaction Decoding
|
||||
@@ -3459,19 +3460,29 @@ Currently supported:
|
||||
name); and one more reads `Unknown (could not be decoded)` when a step that
|
||||
may pay an address went unread. When no step pays anyone, a single line reads
|
||||
`Unknown (not named in the calldata)`. Wherever there is a `Paid to` line, the
|
||||
minimum reads `Min. paid out`. The `Amount` line gives the total the steps
|
||||
take of `Token In`, from the step that sets the input side on: the first V2 or
|
||||
V3 exact-in or exact-out, `WRAP_ETH` or V4 swap step that names an input token
|
||||
or amount. A V4 step with a swap action sets the input side when no earlier
|
||||
step set it, even when it names neither (see Display Consistency). That step
|
||||
counts its own amount, whoever pays it: a V2 or V3 exact-out step its
|
||||
`amountInMax`, and a V4 step what it takes of its input token from the user's
|
||||
wallet, as below, or, when the user pays it none of that token, the `amountIn`
|
||||
of the swap action that spends it. Each later V2 or V3 exact-in or exact-out
|
||||
step whose `payerIsUser` is true takes its amount, found in the same way, from
|
||||
the user's wallet. Every V4 step, with a swap action or without, takes from
|
||||
the user's wallet what its `SETTLE`s paid by the user (`payerIsUser` true) and
|
||||
its `SETTLE_ALL`s pay, for each token on its own; what the step that sets the
|
||||
minimum reads `Min. paid out`. The step that sets the output side gives the
|
||||
minimum. When that step and earlier swap steps each pay the output token to
|
||||
the transaction's sender, the minimum is the sum of their minimums. There is
|
||||
no minimum when the decoder reads none from one of them, or when one of them
|
||||
pays part of that token elsewhere. There is also no minimum when the decoder
|
||||
did not read one of them, or a step between them, in full. A swap step that
|
||||
spends the output token drops earlier steps from the sum. A V4 step spends
|
||||
each token that its swap actions spend. A V4 `SETTLE` or `SETTLE_ALL` of the
|
||||
output token also drops earlier steps. A `PERMIT2_TRANSFER_FROM` of the output
|
||||
token drops earlier steps too. A step after the step that sets the output side
|
||||
drops nothing from the sum. The `Amount` line gives the total the steps take
|
||||
of `Token In`, from the step that sets the input side on: the first V2 or V3
|
||||
exact-in or exact-out, `WRAP_ETH` or V4 swap step that names an input token or
|
||||
amount. A V4 step with a swap action sets the input side when no earlier step
|
||||
set it, even when it names neither (see Display Consistency). That step counts
|
||||
its own amount, whoever pays it: a V2 or V3 exact-out step its `amountInMax`,
|
||||
and a V4 step what it takes of its input token from the user's wallet, as
|
||||
below, or, when the user pays it none of that token, the `amountIn` of the
|
||||
swap action that spends it. Each later V2 or V3 exact-in or exact-out step
|
||||
whose `payerIsUser` is true takes its amount, found in the same way, from the
|
||||
user's wallet. Every V4 step, with a swap action or without, takes from the
|
||||
user's wallet what its `SETTLE`s paid by the user (`payerIsUser` true) and its
|
||||
`SETTLE_ALL`s pay, for each token on its own; what the step that sets the
|
||||
input side takes of any other token counts as a later step's take. A `SETTLE`
|
||||
of any amount but `OPEN_DELTA` pays that amount, and a `SETTLE` of
|
||||
`OPEN_DELTA` or a `SETTLE_ALL` pays what the step owes, as above. So a V4 step
|
||||
|
||||
@@ -22,7 +22,6 @@ const {
|
||||
filterTransactions,
|
||||
} = require("../../shared/transactions");
|
||||
const { resolveEnsNames } = require("../../shared/ens");
|
||||
const { storedNetworkIs } = require("../../shared/storedSettings");
|
||||
const {
|
||||
updateSendBalance,
|
||||
renderSendTokenSelect,
|
||||
@@ -99,7 +98,6 @@ let loadedTxs = [];
|
||||
let ensNameMap = new Map();
|
||||
|
||||
async function loadTransactions(address) {
|
||||
const networkId = state.networkId;
|
||||
try {
|
||||
const rawTxs = await fetchRecentTransactions(
|
||||
address,
|
||||
@@ -116,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>';
|
||||
}
|
||||
|
||||
@@ -29,7 +29,6 @@ const {
|
||||
filterTransactions,
|
||||
} = require("../../shared/transactions");
|
||||
const { resolveEnsNames } = require("../../shared/ens");
|
||||
const { storedNetworkIs } = require("../../shared/storedSettings");
|
||||
const {
|
||||
updateSendBalance,
|
||||
renderSendTokenSelect,
|
||||
@@ -171,7 +170,6 @@ function show() {
|
||||
}
|
||||
|
||||
async function loadTransactions(address, tokenId) {
|
||||
const networkId = state.networkId;
|
||||
try {
|
||||
const rawTxs = await fetchRecentTransactions(
|
||||
address,
|
||||
@@ -188,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);
|
||||
@@ -199,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>';
|
||||
}
|
||||
|
||||
+6
-34
@@ -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);
|
||||
}
|
||||
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 =
|
||||
|
||||
@@ -334,11 +334,6 @@ function showNewSettings() {
|
||||
// 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`.
|
||||
async function saveEndpoint(field, url, networkId) {
|
||||
let refused = false;
|
||||
await saveState((stored) => {
|
||||
@@ -346,7 +341,6 @@ async function saveEndpoint(field, url, networkId) {
|
||||
state.networkId !== networkId || stored.networkId !== networkId;
|
||||
if (refused) return false;
|
||||
state[field] = url;
|
||||
stored[field] = url;
|
||||
});
|
||||
if (refused) {
|
||||
showFlash("The URL was not saved because the network changed.");
|
||||
|
||||
@@ -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 };
|
||||
|
||||
+113
-11
@@ -988,6 +988,9 @@ 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.
|
||||
@@ -1163,6 +1166,8 @@ function decodeV4Swap(input) {
|
||||
}
|
||||
}
|
||||
|
||||
const spent = swaps.map((s) => s.tokenIn);
|
||||
|
||||
// Rule 3.
|
||||
if (swapUndecoded) {
|
||||
return {
|
||||
@@ -1170,6 +1175,7 @@ function decodeV4Swap(input) {
|
||||
tokenOut: takeToken,
|
||||
amountIn: null,
|
||||
amountOutMin: null,
|
||||
spent,
|
||||
takes,
|
||||
settledFromRouter,
|
||||
paidByUser,
|
||||
@@ -1180,7 +1186,6 @@ function decodeV4Swap(input) {
|
||||
};
|
||||
}
|
||||
|
||||
const spent = swaps.map((s) => s.tokenIn);
|
||||
const bought = swaps.map((s) => s.tokenOut);
|
||||
|
||||
// Rules 1 and 2 for Token In.
|
||||
@@ -1216,6 +1221,7 @@ function decodeV4Swap(input) {
|
||||
tokenOut,
|
||||
amountIn,
|
||||
amountOutMin,
|
||||
spent,
|
||||
takes,
|
||||
settledFromRouter,
|
||||
paidByUser,
|
||||
@@ -1307,8 +1313,9 @@ 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. 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 or all buy
|
||||
// it. 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
|
||||
@@ -1423,6 +1430,10 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
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
|
||||
@@ -1455,17 +1466,73 @@ 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 (r === MSG_SENDER || r === sender) {
|
||||
} else if (isSender(recipient)) {
|
||||
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())
|
||||
@@ -1607,6 +1674,7 @@ 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) {
|
||||
@@ -1649,10 +1717,18 @@ 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
|
||||
// and minimum received amount.
|
||||
setOutput(i, s.tokenOut, s.amountOutMin, [s.recipient]);
|
||||
// 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],
|
||||
);
|
||||
if (!s.payerIsUser) {
|
||||
spendFromRouter(s.tokenIn, s.amountIn);
|
||||
}
|
||||
@@ -1673,7 +1749,15 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
} else if (s.payerIsUser) {
|
||||
addUserPaid(s.tokenIn, s.amountIn);
|
||||
}
|
||||
setOutput(i, s.tokenOut, s.amountOutMin, [s.recipient]);
|
||||
dropFromSum(s.tokenIn);
|
||||
setOutput(
|
||||
i,
|
||||
s.tokenOut,
|
||||
swapMinimum(i, s.tokenOut, s.amountOutMin, [
|
||||
s.recipient,
|
||||
]),
|
||||
[s.recipient],
|
||||
);
|
||||
if (!s.payerIsUser) {
|
||||
spendFromRouter(s.tokenIn, s.amountIn);
|
||||
}
|
||||
@@ -1705,7 +1789,15 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
} else if (s.payerIsUser) {
|
||||
addUserPaid(s.tokenIn, s.amountInMax);
|
||||
}
|
||||
setOutput(i, s.tokenOut, s.amountOut, [s.recipient]);
|
||||
dropFromSum(s.tokenIn);
|
||||
setOutput(
|
||||
i,
|
||||
s.tokenOut,
|
||||
swapMinimum(i, s.tokenOut, s.amountOut, [
|
||||
s.recipient,
|
||||
]),
|
||||
[s.recipient],
|
||||
);
|
||||
if (!isHop(i, s.tokenOut, s.recipient)) {
|
||||
addPayee(s.recipient, s.tokenOut);
|
||||
}
|
||||
@@ -1877,6 +1969,11 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
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;
|
||||
@@ -1925,7 +2022,12 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
|
||||
setInput(v4.tokenIn, amountIn);
|
||||
}
|
||||
outputToken = v4.tokenOut;
|
||||
minOutput = v4.amountOutMin;
|
||||
minOutput = swapMinimum(
|
||||
i,
|
||||
v4.tokenOut,
|
||||
v4.amountOutMin,
|
||||
takeRecipients,
|
||||
);
|
||||
outputEstablished = true;
|
||||
outputUnwrapped = false;
|
||||
unwrapIntoRouterStep = null;
|
||||
|
||||
@@ -1,493 +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,
|
||||
},
|
||||
{
|
||||
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,
|
||||
},
|
||||
];
|
||||
}
|
||||
|
||||
// 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);
|
||||
});
|
||||
|
||||
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());
|
||||
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);
|
||||
});
|
||||
@@ -1,49 +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.");
|
||||
},
|
||||
);
|
||||
+352
-2
@@ -2871,8 +2871,9 @@ describe("uniswap decoder", () => {
|
||||
...USDT_400_GROUP,
|
||||
...ONE_USDT_LINES(OTHER_ADDR),
|
||||
],
|
||||
// The last swap step's minimum.
|
||||
minimum: "390.0000 USDC",
|
||||
// Both swap steps pay USDC to the user, so the minimum
|
||||
// is the sum of their two minimums.
|
||||
minimum: "980.0000 USDC",
|
||||
},
|
||||
])(
|
||||
"$kind shows each take's own lines and the allowances, and no Amount figure or Min. received",
|
||||
@@ -3638,6 +3639,355 @@ describe("uniswap decoder", () => {
|
||||
]);
|
||||
});
|
||||
});
|
||||
|
||||
// https://git.eeqj.de/sneak/AutistMask/issues/647 — on next at
|
||||
// f550d8c, a split whose steps each pay WETH to the user showed only
|
||||
// the last step's minimum.
|
||||
describe("the minimum of a split that pays WETH to the user", () => {
|
||||
const WETH_01 = 100000000000000000n;
|
||||
const WETH_02 = 200000000000000000n;
|
||||
const WETH_03 = 300000000000000000n;
|
||||
// A V3 exact-in of 600 USDT for at least 0.3 WETH, and a V2
|
||||
// exact-in of 400 USDT for at least 0.2 WETH, each paid to the
|
||||
// user.
|
||||
const V3_TO_WETH = encodeV3SwapExactIn(
|
||||
USER_ADDR,
|
||||
USDT_600,
|
||||
WETH_03,
|
||||
[USDT_ADDR, WETH_ADDR],
|
||||
);
|
||||
const V2_TO_WETH = encodeV2SwapExactIn(
|
||||
USER_ADDR,
|
||||
USDT_400,
|
||||
WETH_02,
|
||||
[USDT_ADDR, WETH_ADDR],
|
||||
);
|
||||
// A V4 step that swaps 400 USDT for at least 0.2 WETH, with these
|
||||
// TAKEs of the WETH.
|
||||
const v4ToWeth = (...takes) =>
|
||||
encodeV4Swap(
|
||||
new Uint8Array([
|
||||
V4_SWAP_EXACT_IN_SINGLE_ID,
|
||||
V4_SETTLE_ID,
|
||||
...takes.map(() => V4_TAKE_ID),
|
||||
]),
|
||||
[
|
||||
encodeV4ExactInSingle(
|
||||
USDT_ADDR,
|
||||
WETH_ADDR,
|
||||
USDT_400,
|
||||
WETH_02,
|
||||
),
|
||||
encodeV4Settle(USDT_ADDR), // paid by the user
|
||||
...takes,
|
||||
],
|
||||
);
|
||||
// The swap's minimum line as [label, value], or undefined.
|
||||
const minimum = (result) =>
|
||||
result.details
|
||||
.filter(
|
||||
(d) =>
|
||||
d.label === "Min. received" ||
|
||||
d.label === "Min. paid out",
|
||||
)
|
||||
.map((d) => [d.label, d.value])[0];
|
||||
|
||||
test("a V3 and a V2 exact-in show the total of their minimums", () => {
|
||||
const result = decodeSteps(
|
||||
[0x00, 0x08],
|
||||
[V3_TO_WETH, V2_TO_WETH],
|
||||
);
|
||||
expect(minimum(result)).toEqual([
|
||||
"Min. received",
|
||||
"0.5000 WETH",
|
||||
]);
|
||||
});
|
||||
|
||||
test("a V3 exact-in and a V4 step show the total of their minimums", () => {
|
||||
const result = decodeSteps(
|
||||
[0x00, 0x10],
|
||||
[V3_TO_WETH, v4ToWeth(encodeV4Take(WETH_ADDR))],
|
||||
);
|
||||
expect(minimum(result)).toEqual([
|
||||
"Min. received",
|
||||
"0.5000 WETH",
|
||||
]);
|
||||
});
|
||||
|
||||
// The second route buys DAI for the router, then swaps all of it
|
||||
// from the router for at least 0.2 WETH.
|
||||
test("a route that hops through DAI counts its last hop's minimum", () => {
|
||||
const result = decodeSteps(
|
||||
[0x00, 0x08, 0x00],
|
||||
[
|
||||
V3_TO_WETH,
|
||||
encodeV2SwapExactIn(ROUTER_ADDR, USDT_400, DAI_400, [
|
||||
USDT_ADDR,
|
||||
DAI_ADDR,
|
||||
]),
|
||||
coder.encode(
|
||||
["address", "uint256", "uint256", "bytes", "bool"],
|
||||
[
|
||||
USER_ADDR,
|
||||
2n ** 255n, // CONTRACT_BALANCE
|
||||
WETH_02,
|
||||
encodeV3Path([DAI_ADDR, WETH_ADDR]),
|
||||
false, // paid from the router
|
||||
],
|
||||
),
|
||||
],
|
||||
);
|
||||
expect(minimum(result)).toEqual([
|
||||
"Min. received",
|
||||
"0.5000 WETH",
|
||||
]);
|
||||
});
|
||||
|
||||
// The middle step swaps 0.3 of the user's WETH for USDC, so the
|
||||
// sum of minimums starts again after it.
|
||||
test.each([
|
||||
{
|
||||
kind: "a V3 exact-in",
|
||||
command: 0x00,
|
||||
input: encodeV3SwapExactIn(USER_ADDR, WETH_03, 1n, [
|
||||
WETH_ADDR,
|
||||
USDC_ADDR,
|
||||
]),
|
||||
},
|
||||
{
|
||||
kind: "a V2 exact-in",
|
||||
command: 0x08,
|
||||
input: encodeV2SwapExactIn(USER_ADDR, WETH_03, 1n, [
|
||||
WETH_ADDR,
|
||||
USDC_ADDR,
|
||||
]),
|
||||
},
|
||||
{
|
||||
kind: "a V2 exact-out",
|
||||
command: 0x09,
|
||||
input: encodeV2SwapExactOut(USER_ADDR, 1n, WETH_03, [
|
||||
WETH_ADDR,
|
||||
USDC_ADDR,
|
||||
]),
|
||||
},
|
||||
{
|
||||
kind: "a V3 exact-out",
|
||||
command: 0x01,
|
||||
input: encodeV3SwapExactOut(USER_ADDR, 1n, WETH_03, [
|
||||
USDC_ADDR,
|
||||
WETH_ADDR,
|
||||
]),
|
||||
},
|
||||
])(
|
||||
"$kind that spends WETH between them leaves the last step's minimum",
|
||||
({ command, input }) => {
|
||||
const result = decodeSteps(
|
||||
[0x00, command, 0x08],
|
||||
[V3_TO_WETH, input, V2_TO_WETH],
|
||||
);
|
||||
expect(minimum(result)).toEqual([
|
||||
"Min. received",
|
||||
"0.2000 WETH",
|
||||
]);
|
||||
},
|
||||
);
|
||||
|
||||
// The middle step swaps 0.3 WETH and 400 DAI for USDC, both paid
|
||||
// by the user. It spends WETH whichever SETTLE comes last.
|
||||
test.each([
|
||||
{ order: "WETH first", settled: [WETH_ADDR, DAI_ADDR] },
|
||||
{ order: "DAI first", settled: [DAI_ADDR, WETH_ADDR] },
|
||||
])(
|
||||
"a V4 step that spends WETH and DAI between them leaves the last step's minimum, with the SETTLE of $order",
|
||||
({ settled }) => {
|
||||
const wethAndDaiForUsdc = encodeV4Swap(
|
||||
new Uint8Array([
|
||||
V4_SWAP_EXACT_IN_SINGLE_ID,
|
||||
V4_SWAP_EXACT_IN_SINGLE_ID,
|
||||
V4_SETTLE_ID,
|
||||
V4_SETTLE_ID,
|
||||
V4_TAKE_ALL_ID,
|
||||
]),
|
||||
[
|
||||
encodeV4ExactInSingle(
|
||||
WETH_ADDR,
|
||||
USDC_ADDR,
|
||||
WETH_03,
|
||||
1n,
|
||||
),
|
||||
encodeV4ExactInSingle(
|
||||
DAI_ADDR,
|
||||
USDC_ADDR,
|
||||
DAI_400,
|
||||
1n,
|
||||
),
|
||||
...settled.map((token) => encodeV4Settle(token)),
|
||||
encodeV4TakeAll(USDC_ADDR, 0n),
|
||||
],
|
||||
);
|
||||
const result = decodeSteps(
|
||||
[0x00, 0x10, 0x08],
|
||||
[V3_TO_WETH, wethAndDaiForUsdc, V2_TO_WETH],
|
||||
);
|
||||
expect(minimum(result)).toEqual([
|
||||
"Min. received",
|
||||
"0.2000 WETH",
|
||||
]);
|
||||
},
|
||||
);
|
||||
|
||||
// The middle step's swap actions buy WETH with the user's USDT,
|
||||
// then swap all of that WETH for USDC.
|
||||
test("a V4 step that swaps through WETH between them leaves the last step's minimum", () => {
|
||||
const usdtToUsdcThroughWeth = encodeV4Swap(
|
||||
new Uint8Array([
|
||||
V4_SWAP_EXACT_IN_SINGLE_ID,
|
||||
V4_SWAP_EXACT_IN_SINGLE_ID,
|
||||
V4_SETTLE_ID,
|
||||
V4_TAKE_ALL_ID,
|
||||
]),
|
||||
[
|
||||
encodeV4ExactInSingle(
|
||||
USDT_ADDR,
|
||||
WETH_ADDR,
|
||||
USDT_400,
|
||||
WETH_01,
|
||||
),
|
||||
encodeV4ExactInSingle(WETH_ADDR, USDC_ADDR, 0n, 1n),
|
||||
encodeV4Settle(USDT_ADDR), // paid by the user
|
||||
encodeV4TakeAll(USDC_ADDR, 0n),
|
||||
],
|
||||
);
|
||||
const result = decodeSteps(
|
||||
[0x00, 0x10, 0x08],
|
||||
[V3_TO_WETH, usdtToUsdcThroughWeth, V2_TO_WETH],
|
||||
);
|
||||
expect(minimum(result)).toEqual([
|
||||
"Min. received",
|
||||
"0.2000 WETH",
|
||||
]);
|
||||
});
|
||||
|
||||
// The middle step has no swap action. Its SETTLE or SETTLE_ALL
|
||||
// pays 0.3 WETH, and its TAKE pays that WETH to another address.
|
||||
test.each([
|
||||
{
|
||||
payment: "a SETTLE of WETH paid by the user",
|
||||
actions: [V4_SETTLE_ID, V4_TAKE_ID],
|
||||
params: [
|
||||
settle(WETH_ADDR, WETH_03, true),
|
||||
take(WETH_ADDR, OTHER_ADDR, 0n),
|
||||
],
|
||||
},
|
||||
{
|
||||
payment: "a SETTLE of WETH paid from the router",
|
||||
actions: [V4_SETTLE_ID, V4_TAKE_ID],
|
||||
params: [
|
||||
settle(WETH_ADDR, WETH_03, false),
|
||||
take(WETH_ADDR, OTHER_ADDR, 0n),
|
||||
],
|
||||
},
|
||||
{
|
||||
payment: "a SETTLE_ALL of WETH",
|
||||
actions: [V4_TAKE_ID, V4_SETTLE_ALL_ID],
|
||||
params: [
|
||||
take(WETH_ADDR, OTHER_ADDR, WETH_03),
|
||||
encodeV4SettleAll(WETH_ADDR, WETH_03),
|
||||
],
|
||||
},
|
||||
])(
|
||||
"a V4 step with $payment between them leaves the last step's minimum",
|
||||
({ actions, params }) => {
|
||||
const wethToOther = encodeV4Swap(
|
||||
new Uint8Array(actions),
|
||||
params,
|
||||
);
|
||||
const result = decodeSteps(
|
||||
[0x00, 0x10, 0x08],
|
||||
[V3_TO_WETH, wethToOther, V2_TO_WETH],
|
||||
);
|
||||
expect(minimum(result)).toEqual([
|
||||
"Min. paid out",
|
||||
"0.2000 WETH",
|
||||
]);
|
||||
},
|
||||
);
|
||||
|
||||
test("a PERMIT2_TRANSFER_FROM of WETH between them leaves the last step's minimum", () => {
|
||||
const result = decodeSteps(
|
||||
[0x00, 0x02, 0x08],
|
||||
[
|
||||
V3_TO_WETH,
|
||||
permit2TransferFrom(WETH_ADDR, OTHER_ADDR, WETH_03),
|
||||
V2_TO_WETH,
|
||||
],
|
||||
);
|
||||
expect(minimum(result)).toEqual([
|
||||
"Min. paid out",
|
||||
"0.2000 WETH",
|
||||
]);
|
||||
});
|
||||
|
||||
// The decoder reads no minimum from a V4 exact-out action.
|
||||
test("a step that states no minimum leaves no figure", () => {
|
||||
const exactOut = encodeV4Swap(
|
||||
new Uint8Array([
|
||||
V4_SWAP_EXACT_OUT_SINGLE_ID,
|
||||
V4_SETTLE_ALL_ID,
|
||||
V4_TAKE_ALL_ID,
|
||||
]),
|
||||
[
|
||||
encodeV4ExactOutSingle(
|
||||
USDT_ADDR,
|
||||
WETH_ADDR,
|
||||
WETH_02,
|
||||
USDT_400,
|
||||
),
|
||||
encodeV4SettleAll(USDT_ADDR, USDT_400),
|
||||
encodeV4TakeAll(WETH_ADDR, 0n),
|
||||
],
|
||||
);
|
||||
const result = decodeSteps(
|
||||
[0x10, 0x00],
|
||||
[exactOut, V3_TO_WETH],
|
||||
);
|
||||
expect(minimum(result)).toBeUndefined();
|
||||
});
|
||||
|
||||
test("a step that pays some of its WETH to the router leaves no figure", () => {
|
||||
const result = decodeSteps(
|
||||
[0x00, 0x10],
|
||||
[
|
||||
V3_TO_WETH,
|
||||
v4ToWeth(
|
||||
take(WETH_ADDR, USER_ADDR, WETH_01),
|
||||
take(WETH_ADDR, ROUTER_ADDR, 0n),
|
||||
),
|
||||
],
|
||||
);
|
||||
expect(minimum(result)).toBeUndefined();
|
||||
});
|
||||
|
||||
// The router still runs a swap step whose recipient cannot be
|
||||
// read, and that step may spend the WETH the first step paid.
|
||||
test("a step between them that cannot be read leaves no figure", () => {
|
||||
const result = decodeSteps(
|
||||
[0x00, 0x00, 0x08],
|
||||
[
|
||||
V3_TO_WETH,
|
||||
dirtyWord(
|
||||
encodeV3SwapExactIn(USER_ADDR, WETH_03, 1n, [
|
||||
WETH_ADDR,
|
||||
USDC_ADDR,
|
||||
]),
|
||||
0,
|
||||
),
|
||||
V2_TO_WETH,
|
||||
],
|
||||
);
|
||||
expect(minimum(result)).toBeUndefined();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
// https://git.eeqj.de/sneak/AutistMask/issues/359 — the output half, in
|
||||
|
||||
Reference in New Issue
Block a user