Compare commits
2
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 clawbot
|
cd5951a4f8 | ||
|
clawbot
|
bcdffa56a4 |
@@ -1266,8 +1266,7 @@ 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. When earlier swap steps also pay
|
||||
that token to the user, the line shows the sum (see Transaction Decoding).
|
||||
its `amountOut`, the exact amount it buys.
|
||||
- `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
|
||||
@@ -2280,6 +2279,9 @@ view would leave a wallet one click from deletion.
|
||||
no user data and is made whether or not "Use Blockscout" is ticked.
|
||||
- If the network changes before either "Save" stores its URL, the URL is not
|
||||
saved and a flash message says so
|
||||
- Either "Save" stores its URL only if the input still shows that URL when
|
||||
the endpoint answers. Otherwise a flash message says that the URL was not
|
||||
saved
|
||||
- Etherscan:
|
||||
- "Check recipients on Etherscan" checkbox, unticked until the user
|
||||
ticks it
|
||||
@@ -3460,29 +3462,19 @@ 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 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
|
||||
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
|
||||
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
|
||||
|
||||
@@ -334,16 +334,36 @@ 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.
|
||||
async function saveEndpoint(field, url, networkId) {
|
||||
//
|
||||
// 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`.
|
||||
async function saveEndpoint(field, input, url, networkId) {
|
||||
let refused = false;
|
||||
let inputChanged = false;
|
||||
await saveState((stored) => {
|
||||
refused =
|
||||
state.networkId !== networkId || stored.networkId !== networkId;
|
||||
if (refused) return false;
|
||||
inputChanged = $(input).value.trim() !== url;
|
||||
if (refused || inputChanged) return false;
|
||||
state[field] = url;
|
||||
stored[field] = url;
|
||||
});
|
||||
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.");
|
||||
}
|
||||
@@ -395,7 +415,7 @@ function init(_ctx) {
|
||||
showFlash("Could not reach endpoint.");
|
||||
return;
|
||||
}
|
||||
await saveEndpoint("rpcUrl", url, net.id);
|
||||
await saveEndpoint("rpcUrl", "settings-rpc", url, net.id);
|
||||
});
|
||||
|
||||
$("btn-save-blockscout").addEventListener("click", async () => {
|
||||
@@ -419,7 +439,7 @@ function init(_ctx) {
|
||||
showFlash("Could not reach endpoint.");
|
||||
return;
|
||||
}
|
||||
await saveEndpoint("blockscoutUrl", url, net.id);
|
||||
await saveEndpoint("blockscoutUrl", "settings-blockscout", url, net.id);
|
||||
});
|
||||
|
||||
// Each change is made inside the save, holding the lock. So
|
||||
|
||||
+11
-113
@@ -988,9 +988,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 +1163,6 @@ function decodeV4Swap(input) {
|
||||
}
|
||||
}
|
||||
|
||||
const spent = swaps.map((s) => s.tokenIn);
|
||||
|
||||
// Rule 3.
|
||||
if (swapUndecoded) {
|
||||
return {
|
||||
@@ -1175,7 +1170,6 @@ function decodeV4Swap(input) {
|
||||
tokenOut: takeToken,
|
||||
amountIn: null,
|
||||
amountOutMin: null,
|
||||
spent,
|
||||
takes,
|
||||
settledFromRouter,
|
||||
paidByUser,
|
||||
@@ -1186,6 +1180,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 +1216,6 @@ function decodeV4Swap(input) {
|
||||
tokenOut,
|
||||
amountIn,
|
||||
amountOutMin,
|
||||
spent,
|
||||
takes,
|
||||
settledFromRouter,
|
||||
paidByUser,
|
||||
@@ -1313,9 +1307,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
|
||||
@@ -1430,10 +1423,6 @@ 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
|
||||
@@ -1466,73 +1455,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())
|
||||
@@ -1674,7 +1607,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) {
|
||||
@@ -1717,18 +1649,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);
|
||||
}
|
||||
@@ -1749,15 +1673,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);
|
||||
}
|
||||
@@ -1789,15 +1705,7 @@ 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 (!isHop(i, s.tokenOut, s.recipient)) {
|
||||
addPayee(s.recipient, s.tokenOut);
|
||||
}
|
||||
@@ -1969,11 +1877,6 @@ 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;
|
||||
@@ -2022,12 +1925,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;
|
||||
|
||||
@@ -0,0 +1,169 @@
|
||||
// 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.",
|
||||
);
|
||||
},
|
||||
);
|
||||
+2
-352
@@ -2871,9 +2871,8 @@ describe("uniswap decoder", () => {
|
||||
...USDT_400_GROUP,
|
||||
...ONE_USDT_LINES(OTHER_ADDR),
|
||||
],
|
||||
// Both swap steps pay USDC to the user, so the minimum
|
||||
// is the sum of their two minimums.
|
||||
minimum: "980.0000 USDC",
|
||||
// The last swap step's minimum.
|
||||
minimum: "390.0000 USDC",
|
||||
},
|
||||
])(
|
||||
"$kind shows each take's own lines and the allowances, and no Amount figure or Min. received",
|
||||
@@ -3639,355 +3638,6 @@ 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