clawbot
64ec571a17
TxApproval and TransactionDetail cut off a long symbol, amount or description at the edge of the screen. These lines now wrap. SuccessTx hid its Amount and To lines whenever it had a decoded action, even one that showed neither. Each line is now hidden only when a readable decoded line shows the same thing. A swap with no Amount line now shows its amount on SuccessTx, as WaitTx and ErrorTx do. Model: opus-5-5
516 lines
18 KiB
JavaScript
516 lines
18 KiB
JavaScript
// The amount the wait and error screens show for a swap whose amount the
|
|
// decoder did not read (https://git.eeqj.de/sneak/AutistMask/issues/358).
|
|
//
|
|
// A V4 swap action not in the deployed shape is not read, and a V4 exact-out
|
|
// action is read for its currencies only, so the approval screen has no
|
|
// Amount line for either. The wait and error screens then showed the
|
|
// transaction's ETH value as the amount, in the swap's input token when the
|
|
// calldata named one ("0.0000 WETH" for a swap of 1 WETH) and in ETH when it
|
|
// did not ("0.0000 ETH"). They now say the amount could not be decoded. A swap
|
|
// paid in native ETH still shows the transaction's ETH value there: that value
|
|
// is the ETH the swap pays.
|
|
//
|
|
// Driven through the real approval screen, password and Confirm included,
|
|
// against a minimal DOM stub in the shape tests/approvalNonce.test.js uses.
|
|
// The vault is mocked so that no password has to be hashed.
|
|
|
|
jest.mock("../src/shared/vault", () => ({
|
|
decryptWithPassword: jest.fn(),
|
|
}));
|
|
|
|
// The wait screen polls for a receipt, which is there once mockReceipt is set.
|
|
let mockReceipt = null;
|
|
jest.mock("../src/shared/balances", () => ({
|
|
getProvider: () => ({ getTransactionReceipt: async () => mockReceipt }),
|
|
refreshBalances: () => {},
|
|
}));
|
|
|
|
globalThis.chrome = {
|
|
storage: { local: { get: async () => ({}), set: async () => {} } },
|
|
};
|
|
|
|
const { AbiCoder, Interface } = require("ethers");
|
|
const { state } = require("../src/shared/state");
|
|
const { decryptWithPassword } = require("../src/shared/vault");
|
|
const approval = require("../src/popup/views/approval");
|
|
const txStatus = require("../src/popup/views/txStatus");
|
|
|
|
// A well-known test phrase, and its first address.
|
|
const PHRASE = "test test test test test test test test test test test junk";
|
|
const FROM = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266";
|
|
const TX_HASH = "0x" + "4".repeat(64);
|
|
|
|
const ROUTER = "0x66a9893cc07d91d95644aedd05d03f95e1dba8af";
|
|
const ZERO = "0x0000000000000000000000000000000000000000";
|
|
// Both in the bundled list: WETH at 18 decimals, USDC at 6.
|
|
const WETH = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
|
|
const USDC = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
|
|
const ONE_WETH = 1000000000000000000n;
|
|
|
|
const coder = AbiCoder.defaultAbiCoder();
|
|
const routerIface = new Interface([
|
|
"function execute(bytes commands, bytes[] inputs, uint256 deadline)",
|
|
]);
|
|
|
|
// V4 action ids and their parameters, each swapping WETH for USDC.
|
|
const POOL_KEY = "tuple(address,address,uint24,int24,address)";
|
|
const WETH_USDC_POOL = [WETH, USDC, 100, 1, ZERO];
|
|
const SWAP_EXACT_IN_SINGLE = 0x06;
|
|
const SWAP_EXACT_OUT_SINGLE = 0x08;
|
|
const SETTLE = 0x0b;
|
|
const SETTLE_ALL = 0x0c;
|
|
const TAKE = 0x0e;
|
|
const TAKE_ALL = 0x0f;
|
|
|
|
// The struct V4Router has deployed on mainnet and Sepolia.
|
|
const exactInSingle = coder.encode(
|
|
[`tuple(${POOL_KEY},bool,uint128,uint128,bytes)`],
|
|
[[WETH_USDC_POOL, true, ONE_WETH, 990000n, "0x"]],
|
|
);
|
|
// The one v4-periphery `main` has moved to, with a `minHopPriceX36` field.
|
|
const newerExactInSingle = coder.encode(
|
|
[`tuple(${POOL_KEY},bool,uint128,uint128,uint256,bytes)`],
|
|
[[WETH_USDC_POOL, true, ONE_WETH, 990000n, 0n, "0x"]],
|
|
);
|
|
// Deployed shape: buys 990000 base units of USDC for at most 1 WETH.
|
|
const exactOutSingle = coder.encode(
|
|
[`tuple(${POOL_KEY},bool,uint128,uint128,bytes)`],
|
|
[[WETH_USDC_POOL, true, 990000n, ONE_WETH, "0x"]],
|
|
);
|
|
const settleWeth = coder.encode(
|
|
["address", "uint256", "bool"],
|
|
[WETH, 0n, true],
|
|
);
|
|
const takeUsdc = coder.encode(
|
|
["address", "address", "uint256"],
|
|
[USDC, FROM, 0n],
|
|
);
|
|
const settleAllWeth = coder.encode(["address", "uint256"], [WETH, ONE_WETH]);
|
|
const takeAllUsdc = coder.encode(["address", "uint256"], [USDC, 990000n]);
|
|
|
|
// The same swaps paid in native ETH, which V4 names as the zero address.
|
|
const ETH_USDC_POOL = [ZERO, USDC, 500, 10, ZERO];
|
|
const ONE_ETH = 1000000000000000000n;
|
|
const ethExactOutSingle = coder.encode(
|
|
[`tuple(${POOL_KEY},bool,uint128,uint128,bytes)`],
|
|
[[ETH_USDC_POOL, true, 990000n, ONE_ETH, "0x"]],
|
|
);
|
|
const newerEthExactInSingle = coder.encode(
|
|
[`tuple(${POOL_KEY},bool,uint128,uint128,uint256,bytes)`],
|
|
[[ETH_USDC_POOL, true, ONE_ETH, 990000n, 0n, "0x"]],
|
|
);
|
|
// The router pays it from the ETH the transaction sends.
|
|
const settleEth = coder.encode(
|
|
["address", "uint256", "bool"],
|
|
[ZERO, 0n, false],
|
|
);
|
|
|
|
// execute() with one V4_SWAP step of these actions, given as [id, params].
|
|
function v4SwapData(actions) {
|
|
const input = coder.encode(
|
|
["bytes", "bytes[]"],
|
|
[new Uint8Array(actions.map((a) => a[0])), actions.map((a) => a[1])],
|
|
);
|
|
return routerIface.encodeFunctionData("execute", [
|
|
"0x10",
|
|
[input],
|
|
9999999999n,
|
|
]);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
function click(id) {
|
|
return Promise.all((node(id).listeners.click || []).map((fn) => fn()));
|
|
}
|
|
|
|
// Open the approval screen for this calldata, sent to the router with `value`
|
|
// wei (no ETH unless given), and confirm it. The background answers the signed
|
|
// transaction with `response`.
|
|
async function approveSwap(data, response, value = 0n) {
|
|
globalThis.document = makeDocument();
|
|
globalThis.window = { location: { search: "" }, close: () => {} };
|
|
globalThis.chrome.runtime = {
|
|
connect: () => ({ postMessage: () => {} }),
|
|
sendMessage: (msg, reply) => {
|
|
if (!reply) return;
|
|
if (msg.type !== "AUTISTMASK_GET_APPROVAL") return reply(response);
|
|
reply({
|
|
type: "tx",
|
|
origin: "https://dapp.example",
|
|
isPhishingDomain: false,
|
|
approvedFrom: FROM,
|
|
approvedTx: {
|
|
type: 2,
|
|
from: FROM,
|
|
chainId: "0x1",
|
|
nonce: "0x7",
|
|
gasLimit: "0x30d40",
|
|
maxPriorityFeePerGas: "0x3b9aca00",
|
|
maxFeePerGas: "0x77359400",
|
|
to: ROUTER,
|
|
value: "0x" + value.toString(16),
|
|
data,
|
|
accessList: [],
|
|
},
|
|
});
|
|
},
|
|
};
|
|
state.activeAddress = FROM;
|
|
state.trackedTokens = [];
|
|
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: [] },
|
|
],
|
|
},
|
|
];
|
|
txStatus.init({ doRefreshAndRender: () => {} });
|
|
approval.init({});
|
|
await approval.show(1);
|
|
decryptWithPassword.mockResolvedValue(PHRASE);
|
|
node("approve-tx-password").value = "any password";
|
|
await click("btn-approve-tx");
|
|
}
|
|
|
|
// A later popup resumes the wait, and the receipt is there.
|
|
async function receiptArrives() {
|
|
mockReceipt = { blockNumber: 1 };
|
|
txStatus.restoreWait();
|
|
for (let i = 0; i < 10; i++) {
|
|
await new Promise((r) => setTimeout(r, 0));
|
|
}
|
|
}
|
|
|
|
afterEach(() => {
|
|
txStatus.endWait();
|
|
mockReceipt = null;
|
|
});
|
|
|
|
describe.each([
|
|
[
|
|
"a swap action in the deployed shape",
|
|
[
|
|
[SWAP_EXACT_IN_SINGLE, exactInSingle],
|
|
[SETTLE, settleWeth],
|
|
[TAKE, takeUsdc],
|
|
],
|
|
"1.0000 WETH",
|
|
],
|
|
[
|
|
"a swap action in the newer shape, with SETTLE naming WETH",
|
|
[
|
|
[SWAP_EXACT_IN_SINGLE, newerExactInSingle],
|
|
[SETTLE, settleWeth],
|
|
[TAKE, takeUsdc],
|
|
],
|
|
"Unknown (could not be decoded)",
|
|
],
|
|
[
|
|
"a swap action in the newer shape, with SETTLE_ALL and TAKE_ALL",
|
|
[
|
|
[SWAP_EXACT_IN_SINGLE, newerExactInSingle],
|
|
[SETTLE_ALL, settleAllWeth],
|
|
[TAKE_ALL, takeAllUsdc],
|
|
],
|
|
"Unknown (could not be decoded)",
|
|
],
|
|
[
|
|
"an exact-out swap action, which is read for its currencies only",
|
|
[
|
|
[SWAP_EXACT_OUT_SINGLE, exactOutSingle],
|
|
[SETTLE, settleWeth],
|
|
[TAKE, takeUsdc],
|
|
],
|
|
"Unknown (could not be decoded)",
|
|
],
|
|
])("%s", (_name, actions, expected) => {
|
|
test("the wait screen's amount", async () => {
|
|
await approveSwap(v4SwapData(actions), { txHash: TX_HASH });
|
|
expect(node("wait-tx-summary").textContent).toBe(expected);
|
|
});
|
|
|
|
test("the error screen's amount", async () => {
|
|
await approveSwap(v4SwapData(actions), {
|
|
error: "The transaction could not be sent.",
|
|
retryable: false,
|
|
});
|
|
expect(node("error-tx-summary").textContent).toBe(expected);
|
|
});
|
|
|
|
// The success screen has an Amount line of its own only when the approval
|
|
// screen's decoded lines have none. The ETH value is on neither.
|
|
test("the success screen's amount", async () => {
|
|
await approveSwap(v4SwapData(actions), { txHash: TX_HASH });
|
|
await receiptArrives();
|
|
const summary = node("success-tx-summary");
|
|
expect(summary.parentElement.classList.contains("hidden")).toBe(
|
|
!expected.startsWith("Unknown"),
|
|
);
|
|
expect(summary.textContent).toBe(expected);
|
|
expect(node("success-tx-decoded").innerHTML).not.toContain("0.0000");
|
|
});
|
|
|
|
// The Protocol line of the decoded lines shows the router.
|
|
test("the success screen has no To line of its own", async () => {
|
|
await approveSwap(v4SwapData(actions), { txHash: TX_HASH });
|
|
await receiptArrives();
|
|
const to = node("success-tx-to").parentElement;
|
|
expect(to.classList.contains("hidden")).toBe(true);
|
|
expect(node("success-tx-decoded").innerHTML).toContain(ROUTER);
|
|
});
|
|
});
|
|
|
|
// A swap paid in native ETH has a Token In of "ETH (native)" and no Amount
|
|
// line, and sends 1 ETH.
|
|
describe.each([
|
|
[
|
|
"an exact-out swap action paid in ETH, in the deployed shape",
|
|
[
|
|
[SWAP_EXACT_OUT_SINGLE, ethExactOutSingle],
|
|
[SETTLE, settleEth],
|
|
[TAKE, takeUsdc],
|
|
],
|
|
],
|
|
[
|
|
"a swap action in the newer shape paid in ETH, with SETTLE naming ETH",
|
|
[
|
|
[SWAP_EXACT_IN_SINGLE, newerEthExactInSingle],
|
|
[SETTLE, settleEth],
|
|
[TAKE, takeUsdc],
|
|
],
|
|
],
|
|
])("%s", (_name, actions) => {
|
|
test("the wait screen shows the ETH the transaction sends", async () => {
|
|
await approveSwap(v4SwapData(actions), { txHash: TX_HASH }, ONE_ETH);
|
|
expect(node("wait-tx-summary").textContent).toBe("1.0000 ETH");
|
|
});
|
|
|
|
test("the error screen shows the ETH the transaction sends", async () => {
|
|
await approveSwap(
|
|
v4SwapData(actions),
|
|
{
|
|
error: "The transaction could not be sent.",
|
|
retryable: false,
|
|
},
|
|
ONE_ETH,
|
|
);
|
|
expect(node("error-tx-summary").textContent).toBe("1.0000 ETH");
|
|
});
|
|
|
|
test("the success screen shows the ETH the transaction sends", async () => {
|
|
await approveSwap(v4SwapData(actions), { txHash: TX_HASH }, ONE_ETH);
|
|
await receiptArrives();
|
|
const summary = node("success-tx-summary");
|
|
expect(summary.parentElement.classList.contains("hidden")).toBe(false);
|
|
expect(summary.textContent).toBe("1.0000 ETH");
|
|
});
|
|
});
|
|
|
|
// https://git.eeqj.de/sneak/AutistMask/issues/722: a WRAP_ETH of 1 ETH into the
|
|
// router, an UNWRAP_WETH into the router, then a V4 swap of 1 ETH the user
|
|
// settles. The Amount line reads 1.0000 ETH, though up to 2 ETH can leave. The
|
|
// rest is on the swap's own Moved from the sender line.
|
|
describe("a swap with a Moved from the sender line of its own", () => {
|
|
const ADDRESS_THIS = "0x0000000000000000000000000000000000000002";
|
|
const TWO_ETH = 2n * ONE_ETH;
|
|
const SEND_FAILS = {
|
|
error: "The transaction could not be sent.",
|
|
retryable: false,
|
|
};
|
|
const data = routerIface.encodeFunctionData("execute", [
|
|
"0x0b0c10",
|
|
[
|
|
// WRAP_ETH and UNWRAP_WETH have the same layout.
|
|
coder.encode(["address", "uint256"], [ADDRESS_THIS, ONE_ETH]),
|
|
coder.encode(["address", "uint256"], [ADDRESS_THIS, 0n]),
|
|
coder.encode(
|
|
["bytes", "bytes[]"],
|
|
[
|
|
new Uint8Array([SWAP_EXACT_IN_SINGLE, SETTLE, TAKE_ALL]),
|
|
[
|
|
coder.encode(
|
|
[`tuple(${POOL_KEY},bool,uint128,uint128,bytes)`],
|
|
[[ETH_USDC_POOL, true, ONE_ETH, 990000n, "0x"]],
|
|
),
|
|
// The user pays this one, not the router.
|
|
coder.encode(
|
|
["address", "uint256", "bool"],
|
|
[ZERO, 0n, true],
|
|
),
|
|
takeAllUsdc,
|
|
],
|
|
],
|
|
),
|
|
],
|
|
9999999999n,
|
|
]);
|
|
|
|
function expectMovedLine(id) {
|
|
const html = node(id).innerHTML;
|
|
expect(html).toContain("Moved from the sender");
|
|
expect(html).toContain("Up to 1.0000 ETH");
|
|
}
|
|
|
|
test("the wait screen shows that line's amount under the Amount figure", async () => {
|
|
await approveSwap(data, { txHash: TX_HASH }, TWO_ETH);
|
|
expect(node("wait-tx-summary").textContent).toBe("1.0000 ETH");
|
|
expectMovedLine("wait-tx-token-note");
|
|
});
|
|
|
|
test("the error screen shows that line's amount under the Amount figure", async () => {
|
|
await approveSwap(data, SEND_FAILS, TWO_ETH);
|
|
expect(node("error-tx-summary").textContent).toBe("1.0000 ETH");
|
|
expectMovedLine("error-tx-token-note");
|
|
});
|
|
|
|
test("a reopened popup's wait screen still shows it", async () => {
|
|
await approveSwap(data, { txHash: TX_HASH }, TWO_ETH);
|
|
node("wait-tx-token-note").innerHTML = "";
|
|
txStatus.restoreWait();
|
|
expectMovedLine("wait-tx-token-note");
|
|
});
|
|
|
|
test("a reopened popup's error screen still shows it", async () => {
|
|
await approveSwap(data, SEND_FAILS, TWO_ETH);
|
|
node("error-tx-token-note").innerHTML = "";
|
|
txStatus.renderError();
|
|
expectMovedLine("error-tx-token-note");
|
|
});
|
|
});
|
|
|
|
// https://git.eeqj.de/sneak/AutistMask/issues/733: a PERMIT2_PERMIT that gives
|
|
// another spender an unlimited USDC allowance, then a V4 swap of 1 ETH. The
|
|
// Amount line reads 1.0000 ETH and says nothing of the allowance.
|
|
describe("a swap that gives another spender an allowance", () => {
|
|
const OTHER_SPENDER = "0x1111111111111111111111111111111111111111";
|
|
const MAX_UINT160 = (1n << 160n) - 1n;
|
|
const SEND_FAILS = {
|
|
error: "The transaction could not be sent.",
|
|
retryable: false,
|
|
};
|
|
const data = routerIface.encodeFunctionData("execute", [
|
|
"0x0a10",
|
|
[
|
|
coder.encode(
|
|
[
|
|
"tuple(tuple(address,uint160,uint48,uint48),address,uint256)",
|
|
"bytes",
|
|
],
|
|
[
|
|
[[USDC, MAX_UINT160, 0, 0], OTHER_SPENDER, 9999999999n],
|
|
"0x1234",
|
|
],
|
|
),
|
|
coder.encode(
|
|
["bytes", "bytes[]"],
|
|
[
|
|
new Uint8Array([SWAP_EXACT_IN_SINGLE, SETTLE, TAKE]),
|
|
[
|
|
coder.encode(
|
|
[`tuple(${POOL_KEY},bool,uint128,uint128,bytes)`],
|
|
[[ETH_USDC_POOL, true, ONE_ETH, 990000n, "0x"]],
|
|
),
|
|
settleEth,
|
|
takeUsdc,
|
|
],
|
|
],
|
|
),
|
|
],
|
|
9999999999n,
|
|
]);
|
|
|
|
function expectAllowanceLine(id) {
|
|
const html = node(id).innerHTML;
|
|
expect(html).toContain("Permit2 allowance");
|
|
expect(html).toContain("Unlimited");
|
|
expect(html).toContain("Allowance token");
|
|
expect(html).toContain('<div class="font-bold break-words">USDC</div>');
|
|
expect(html).toContain(`data-copy="${USDC}"`);
|
|
}
|
|
|
|
test("the wait screen shows the allowance under the Amount figure", async () => {
|
|
await approveSwap(data, { txHash: TX_HASH }, ONE_ETH);
|
|
expect(node("wait-tx-summary").textContent).toBe("1.0000 ETH");
|
|
expectAllowanceLine("wait-tx-token-note");
|
|
});
|
|
|
|
test("the error screen shows the allowance under the Amount figure", async () => {
|
|
await approveSwap(data, SEND_FAILS, ONE_ETH);
|
|
expect(node("error-tx-summary").textContent).toBe("1.0000 ETH");
|
|
expectAllowanceLine("error-tx-token-note");
|
|
});
|
|
|
|
test("a reopened popup's wait screen still shows it", async () => {
|
|
await approveSwap(data, { txHash: TX_HASH }, ONE_ETH);
|
|
node("wait-tx-token-note").innerHTML = "";
|
|
txStatus.restoreWait();
|
|
expectAllowanceLine("wait-tx-token-note");
|
|
});
|
|
|
|
test("a reopened popup's error screen still shows it", async () => {
|
|
await approveSwap(data, SEND_FAILS, ONE_ETH);
|
|
node("error-tx-token-note").innerHTML = "";
|
|
txStatus.renderError();
|
|
expectAllowanceLine("error-tx-token-note");
|
|
});
|
|
});
|