Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 sneak
|
01dce26807 |
@@ -464,6 +464,9 @@ papered over:
|
||||
forced by clicking Reveal and the settings gear in one page task, which a
|
||||
person cannot do; the case a person can hit, the first decrypt after the popup
|
||||
opens while libsodium is still loading, is not driven.
|
||||
- Approval windows open at 1280x720 whatever size the extension asks for, so
|
||||
whether an approval screen fits its window is checked in the Firefox suite
|
||||
only.
|
||||
|
||||
Any test that drives a failure path on purpose declares the `console.error` it
|
||||
is about to provoke, via `errors.expect()`. That is not a mute: the declaration
|
||||
@@ -536,7 +539,8 @@ suite), wallet creation through the UI, the Add Token screen, and the dApp round
|
||||
trips — `eth_requestAccounts`, `personal_sign`, `wallet_switchEthereumChain`
|
||||
rejected and then approved, `eth_sendTransaction`, and a closed approval window
|
||||
rejecting with EIP-1193 4001 — driven through the real content script,
|
||||
background page and approval windows.
|
||||
background page and approval windows. The `personal_sign` prompt is also
|
||||
required to fit its window without scrolling sideways.
|
||||
|
||||
The suite lives in `tests/e2e/firefox/`. Its WebDriver client (`driver.js`) has
|
||||
**no npm dependencies at all**: it is built on global `fetch` and
|
||||
@@ -893,8 +897,11 @@ discoverable.
|
||||
enough that vanilla JS with simple view switching is sufficient. A framework
|
||||
would add bundle size, build complexity, and attack surface for no benefit at
|
||||
this scale.
|
||||
- **360x600 popup**: Standard browser extension popup dimensions. The UI is
|
||||
designed for this fixed viewport.
|
||||
- **396x600 popup**: The page is 396 pixels wide (`body` in
|
||||
`src/popup/styles/main.css`), and 600 pixels is as tall as the browser lets
|
||||
the toolbar popup grow. The UI is designed for this fixed viewport. The window
|
||||
an approval opens in is given the same size; the browser counts the window's
|
||||
frame in its width, so the page widens the window by whatever the frame takes.
|
||||
|
||||
#### No Layout Shift
|
||||
|
||||
@@ -1645,12 +1652,6 @@ view would leave a wallet one click from deletion.
|
||||
the contract's own answer is read at signing time only to be compared with
|
||||
it, and a disagreement is a refusal rather than a preference for either
|
||||
value (`src/shared/transferAmount.js`)
|
||||
- "Sign & Send" after the active network was switched in Settings while this
|
||||
screen was open → nothing is signed; "The active network changed after
|
||||
this transaction was reviewed, so it was not sent. Please go back and
|
||||
review it again." in the errors box, no screen change. The transaction
|
||||
carries the chain id of the network the screen was shown for, so it cannot
|
||||
be signed for another
|
||||
- "Sign & Send" (wrong password) → "Wrong password." on the password error
|
||||
line, no screen change
|
||||
- "Back" → **Send**
|
||||
@@ -2136,12 +2137,7 @@ view would leave a wallet one click from deletion.
|
||||
blocklist)
|
||||
- Site origin (bold, scheme and port included) + "wants you to sign a
|
||||
message"
|
||||
- Warning box, shown for `eth_sign`: "This site used the older eth_sign
|
||||
method. The data will be signed as a personal message." An `eth_sign`
|
||||
request names the address first and the data second. Its data is signed
|
||||
exactly as a `personal_sign` message is, as an EIP-191 personal message,
|
||||
which is what the Ethereum JSON-RPC specification defines `eth_sign` to
|
||||
return.
|
||||
- Danger warning box (shown for `eth_sign`, which signs a raw hash)
|
||||
- Type: "Personal message" or "Typed data (EIP-712)"
|
||||
- From: color dot + full address + etherscan link
|
||||
- Message: for `personal_sign` and `eth_sign`, the text the message's bytes
|
||||
@@ -2156,12 +2152,7 @@ view would leave a wallet one click from deletion.
|
||||
Bytes that are not UTF-8 are shown as "This message is not text." For
|
||||
typed data, formatted domain/type/message fields (EIP-712). The primary
|
||||
type shown is the one ethers signs, derived from the typed data's `types`,
|
||||
not the type the site states. The message shows only the fields that type
|
||||
declares, at every level of nesting and in the type's order: ethers signs
|
||||
those and drops any other key. Typed data carrying other keys is not
|
||||
refused; each such key is listed after the message under "Not part of the
|
||||
signature", by its place in the message (`details.note`,
|
||||
`details[1].note`) and its value.
|
||||
not the type the site states.
|
||||
- Token permission warning, at the top of the message (typed data whose
|
||||
primary type is `Permit`, as in EIP-2612, or one of Permit2's signature
|
||||
types): "⚠️ TOKEN PERMISSION: Signing this lets the spender below take the
|
||||
|
||||
@@ -423,7 +423,10 @@ function releaseApproval(approval) {
|
||||
// the result on the floor, so a rejection here would be unhandled.
|
||||
async function openApprovalWindow(id) {
|
||||
const popupUrl = runtime.getURL("src/popup/index.html?approval=" + id);
|
||||
const popupWidth = 360;
|
||||
// As wide as the page: body in src/popup/styles/main.css. The browser
|
||||
// counts the window's frame in this width; the page itself adds back
|
||||
// whatever the frame takes (src/popup/index.js).
|
||||
const popupWidth = 396;
|
||||
const popupHeight = 600;
|
||||
|
||||
let currentWin = null;
|
||||
@@ -443,7 +446,7 @@ async function openApprovalWindow(id) {
|
||||
// Centred on a browser window only. The last focused window can be
|
||||
// another approval window still open, and centring on one can give a
|
||||
// position the browser refuses ("Bounds must be at least 50% within
|
||||
// visible screen space"): headless Chrome reports this 360x600 popup as
|
||||
// visible screen space"): headless Chrome reports this 396x600 popup as
|
||||
// 1280x720. The request then failed with no window at all. Over a popup,
|
||||
// the browser picks the position.
|
||||
if (currentWin && currentWin.type === "normal") {
|
||||
@@ -988,8 +991,9 @@ async function handleRpc(method, params, origin) {
|
||||
|
||||
if (method === "eth_sign") {
|
||||
signParams.dangerWarning =
|
||||
"This site used the older eth_sign method. " +
|
||||
"The data will be signed as a personal message.";
|
||||
"\u26a0\ufe0f DANGER: This site is requesting to sign a raw hash. " +
|
||||
"This can be used to sign transactions that drain your funds. " +
|
||||
"Only proceed if you fully understand what you are signing.";
|
||||
}
|
||||
|
||||
if (findPendingApproval(origin, "sign")) {
|
||||
|
||||
@@ -21,6 +21,7 @@ const {
|
||||
goBack,
|
||||
} = require("./views/helpers");
|
||||
const { applyTheme } = require("./theme");
|
||||
const { windowsGetCurrent, windowsUpdate } = require("../shared/browserApi");
|
||||
// Renders a view the popup lands on without having navigated to it forward:
|
||||
// on restore here, and on Back. Only the views that can be fully re-rendered
|
||||
// from persisted state (RESTORABLE_VIEWS, src/shared/restorableViews.js) go
|
||||
@@ -233,6 +234,22 @@ async function init() {
|
||||
const params = new URLSearchParams(window.location.search);
|
||||
const approvalId = params.get("approval");
|
||||
if (approvalId) {
|
||||
// The background opens this window as wide as the page, but the
|
||||
// browser counts the window's frame in that width, and how wide the
|
||||
// frame is depends on the browser and the system. The window is
|
||||
// widened by however far the page would scroll sideways. The
|
||||
// connection prompt can also show in the toolbar popup, whose window
|
||||
// is the user's browser window; that one is left alone.
|
||||
const sideways =
|
||||
document.documentElement.scrollWidth -
|
||||
document.documentElement.clientWidth;
|
||||
if (sideways > 0) {
|
||||
windowsGetCurrent().then((win) => {
|
||||
if (win.type === "popup") {
|
||||
windowsUpdate(win.id, { width: win.width + sideways });
|
||||
}
|
||||
});
|
||||
}
|
||||
// Deliberately not awaited, and deliberately not .catch()ed. show()
|
||||
// is async, so a throw past its first await surfaces as an unhandled
|
||||
// rejection rather than an uncaught error — measured as still failing
|
||||
|
||||
@@ -626,38 +626,10 @@ function permitWarningHtml(types, primaryType, domain, message) {
|
||||
return html;
|
||||
}
|
||||
|
||||
// What ethers signs of a message value of type `type`: a struct keeps only
|
||||
// the fields its type declares, in the type's order, and a list is read item
|
||||
// by item. ethers drops every other key, so each one is added to `notSigned`
|
||||
// with its place in the message and its value, for the screen to list apart.
|
||||
function signedValue(types, type, value, path, notSigned) {
|
||||
const itemType = type.replace(/\[\d*\]$/, "");
|
||||
if (itemType !== type) {
|
||||
if (!Array.isArray(value)) return value;
|
||||
return value.map((item, i) =>
|
||||
signedValue(types, itemType, item, `${path}[${i}]`, notSigned),
|
||||
);
|
||||
}
|
||||
const fields = types[type];
|
||||
if (!fields || !value || typeof value !== "object") return value;
|
||||
const at = (name) => (path ? `${path}.${name}` : name);
|
||||
for (const [key, val] of Object.entries(value)) {
|
||||
if (!fields.some((f) => f.name === key)) notSigned.push([at(key), val]);
|
||||
}
|
||||
return Object.fromEntries(
|
||||
fields.map((f) => [
|
||||
f.name,
|
||||
signedValue(types, f.type, value[f.name], at(f.name), notSigned),
|
||||
]),
|
||||
);
|
||||
}
|
||||
|
||||
// The typed data as the screen shows it. The primary type shown is the one
|
||||
// ethers signs, never the page's word for it; typedDataRefusal() keeps the two
|
||||
// from differing on anything that can be signed. The Message section shows
|
||||
// only what is signed, and any other key the page sent is listed after it as
|
||||
// not part of the signature. Only typed data that cannot be read at all is
|
||||
// shown as raw text, and typedDataRefusal() refuses it.
|
||||
// from differing on anything that can be signed. Only typed data that cannot
|
||||
// be read at all is shown as raw text, and typedDataRefusal() refuses it.
|
||||
function formatTypedDataHtml(jsonStr) {
|
||||
let data;
|
||||
let primaryType;
|
||||
@@ -691,30 +663,12 @@ function formatTypedDataHtml(jsonStr) {
|
||||
html += `<div class="mb-2"><div class="text-muted">Primary type</div>`;
|
||||
html += `<div class="font-bold">${escapeHtml(primaryType)}</div></div>`;
|
||||
|
||||
const lineHtml = (key, val) =>
|
||||
`<div><span class="text-muted">${escapeHtml(key)}:</span> <span class="break-all">${escapeHtml(display(val))}</span></div>`;
|
||||
|
||||
if (data.message) {
|
||||
const notSigned = [];
|
||||
const message = signedValue(
|
||||
data.types,
|
||||
primaryType,
|
||||
data.message,
|
||||
"",
|
||||
notSigned,
|
||||
);
|
||||
html += `<div class="mb-2"><div class="text-muted">Message</div>`;
|
||||
for (const [key, val] of Object.entries(message)) {
|
||||
html += lineHtml(key, val);
|
||||
for (const [key, val] of Object.entries(data.message)) {
|
||||
html += `<div><span class="text-muted">${escapeHtml(key)}:</span> <span class="break-all">${escapeHtml(display(val))}</span></div>`;
|
||||
}
|
||||
html += `</div>`;
|
||||
if (notSigned.length > 0) {
|
||||
html += `<div class="mb-2"><div class="text-muted">Not part of the signature</div>`;
|
||||
for (const [key, val] of notSigned) {
|
||||
html += lineHtml(key, val);
|
||||
}
|
||||
html += `</div>`;
|
||||
}
|
||||
}
|
||||
|
||||
return html;
|
||||
@@ -771,7 +725,7 @@ function showSignApproval(details) {
|
||||
"This message is plain text, not hex, so it cannot be signed.";
|
||||
}
|
||||
|
||||
// The warning the background attaches to an eth_sign request.
|
||||
// Display danger warning for eth_sign (raw hash signing)
|
||||
const warningEl = $("approve-sign-danger-warning");
|
||||
if (warningEl) {
|
||||
if (sp.dangerWarning) {
|
||||
|
||||
@@ -101,10 +101,6 @@ function show(txInfo) {
|
||||
feeStatus = FEE_PENDING;
|
||||
feeWei = null;
|
||||
maxSendFees = null;
|
||||
// The network this screen is drawn for, and the only one it sends on:
|
||||
// Settings can switch the active network while the screen is open. The
|
||||
// wait, success and error screens label the amount by it too.
|
||||
txInfo.chainId = currentNetwork().chainId;
|
||||
|
||||
const isErc20 = txInfo.token !== "ETH";
|
||||
// The raw symbol is the price-table key; the capped one is what the
|
||||
@@ -494,12 +490,7 @@ async function populateVerifyAndSend(connectedSigner, tx, fees = null) {
|
||||
);
|
||||
request = await contract.transfer.populateTransaction(tx.to, amount);
|
||||
}
|
||||
// The chain id of the network the screen was drawn for: ethers refuses to
|
||||
// populate it for a provider on any other network.
|
||||
const populated = await connectedSigner.populateTransaction({
|
||||
...request,
|
||||
chainId: tx.chainId,
|
||||
});
|
||||
const populated = await connectedSigner.populateTransaction(request);
|
||||
assertWithinCeilings(populated);
|
||||
return connectedSigner.sendTransaction(populated);
|
||||
}
|
||||
@@ -556,17 +547,6 @@ function init(_ctx) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Back from Settings only unhides this screen, still drawn for the
|
||||
// network that was active when it was shown.
|
||||
if (currentNetwork().chainId !== pendingTx.chainId) {
|
||||
showSendError(
|
||||
"The active network changed after this transaction was" +
|
||||
" reviewed, so it was not sent. Please go back and review" +
|
||||
" it again.",
|
||||
);
|
||||
return;
|
||||
}
|
||||
|
||||
const password = $("confirm-tx-password").value;
|
||||
if (!password) {
|
||||
showError(
|
||||
@@ -595,6 +575,10 @@ function init(_ctx) {
|
||||
$("btn-confirm-send").disabled = true;
|
||||
$("btn-confirm-send").classList.add("text-muted");
|
||||
|
||||
// The network it is sent on. The wait, success and error screens
|
||||
// label its amount by this, not by the network active when they draw.
|
||||
pendingTx.chainId = currentNetwork().chainId;
|
||||
|
||||
let tx;
|
||||
try {
|
||||
const signer = getSignerForAddress(
|
||||
|
||||
@@ -183,7 +183,7 @@ function render() {
|
||||
if (el) el.classList.add("hidden");
|
||||
}
|
||||
|
||||
loadFullTxDetails(tx.hash, tx.chainId);
|
||||
loadFullTxDetails(tx.hash, tx.to, tx.chainId);
|
||||
|
||||
const isoStr = isoDate(tx.timestamp);
|
||||
$("tx-detail-time").innerHTML =
|
||||
@@ -291,7 +291,7 @@ function populateOnChainDetails(txData, chainId) {
|
||||
}
|
||||
}
|
||||
|
||||
async function loadFullTxDetails(txHash, chainId) {
|
||||
async function loadFullTxDetails(txHash, toAddress, chainId) {
|
||||
const section = $("tx-detail-calldata-section");
|
||||
const actionEl = $("tx-detail-calldata-action");
|
||||
const detailsEl = $("tx-detail-calldata-details");
|
||||
@@ -313,10 +313,7 @@ async function loadFullTxDetails(txHash, chainId) {
|
||||
const inputData = txData.raw_input || txData.input || null;
|
||||
if (!inputData || inputData === "0x") return;
|
||||
|
||||
// Decoded against the address the transaction was sent to, as the
|
||||
// explorer reports it, not the history entry's `to`: for a token
|
||||
// transfer that is the transfer's recipient, not the token contract.
|
||||
const decoded = decodeCalldata(inputData, txData.to?.hash || "");
|
||||
const decoded = decodeCalldata(inputData, toAddress || "");
|
||||
if (decoded) {
|
||||
// Render decoded calldata matching approval view style
|
||||
actionEl.textContent = decoded.name;
|
||||
|
||||
@@ -250,6 +250,22 @@ function windowsGetLastFocused() {
|
||||
return invoke(windowsApi(), "getLastFocused");
|
||||
}
|
||||
|
||||
/**
|
||||
* @returns {Promise<Object>} the window the calling page is in.
|
||||
*/
|
||||
function windowsGetCurrent() {
|
||||
return invoke(windowsApi(), "getCurrent");
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {number} windowId
|
||||
* @param {Object} updateInfo
|
||||
* @returns {Promise<Object>} the updated window.
|
||||
*/
|
||||
function windowsUpdate(windowId, updateInfo) {
|
||||
return invoke(windowsApi(), "update", windowId, updateInfo);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {number} windowId
|
||||
* @returns {Promise<void>}
|
||||
@@ -275,6 +291,8 @@ module.exports = {
|
||||
tabsSendMessage,
|
||||
windowsApi,
|
||||
windowsCreate,
|
||||
windowsGetCurrent,
|
||||
windowsGetLastFocused,
|
||||
windowsRemove,
|
||||
windowsUpdate,
|
||||
};
|
||||
|
||||
@@ -45,3 +45,50 @@ test("the approval window shows no screen until the background describes the app
|
||||
expect(env.visibleViews()).toEqual(["approve-network"]);
|
||||
expect(env.pageErrors).toEqual([]);
|
||||
});
|
||||
|
||||
// The background opens the approval window as wide as the page, but the
|
||||
// browser counts the window's frame in that width
|
||||
// (https://git.eeqj.de/sneak/AutistMask/issues/518). The browser suites run
|
||||
// without frames, so the widening is checked here.
|
||||
function windowsStub(type) {
|
||||
const updates = [];
|
||||
return {
|
||||
updates,
|
||||
getCurrent: (done) => done({ id: 7, type, width: 396 }),
|
||||
update: (id, info, done) => {
|
||||
updates.push({ id, info });
|
||||
done({});
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
const approvalRuntime = {
|
||||
connect: () => ({ postMessage: () => {} }),
|
||||
sendMessage: () => {},
|
||||
};
|
||||
|
||||
test("the approval window widens itself by whatever its frame takes", async () => {
|
||||
const windows = windowsStub("popup");
|
||||
const env = await bootPopup(unversionedValidProfile(), {
|
||||
search: "?approval=approval-1",
|
||||
runtime: approvalRuntime,
|
||||
windows,
|
||||
documentElement: { scrollWidth: 396, clientWidth: 380 },
|
||||
});
|
||||
|
||||
expect(windows.updates).toEqual([{ id: 7, info: { width: 412 } }]);
|
||||
expect(env.pageErrors).toEqual([]);
|
||||
});
|
||||
|
||||
test("a connection prompt in the toolbar popup leaves the browser window alone", async () => {
|
||||
const windows = windowsStub("normal");
|
||||
const env = await bootPopup(unversionedValidProfile(), {
|
||||
search: "?approval=approval-1",
|
||||
runtime: approvalRuntime,
|
||||
windows,
|
||||
documentElement: { scrollWidth: 396, clientWidth: 380 },
|
||||
});
|
||||
|
||||
expect(windows.updates).toEqual([]);
|
||||
expect(env.pageErrors).toEqual([]);
|
||||
});
|
||||
|
||||
@@ -1606,55 +1606,6 @@ describe("what the approval is verified against", () => {
|
||||
});
|
||||
});
|
||||
|
||||
// eth_sign names the address first and the data second, the reverse of
|
||||
// personal_sign, and is answered as the JSON-RPC specification defines it:
|
||||
// with an EIP-191 personal message signature over the data, the same
|
||||
// signature personal_sign returns
|
||||
// (https://git.eeqj.de/sneak/AutistMask/issues/409). The signature below is
|
||||
// made by the test; that the sign screen makes the same one is tested in
|
||||
// tests/ethSign.test.js.
|
||||
describe("eth_sign", () => {
|
||||
test("is read address first, and returns a personal message signature over the data", async () => {
|
||||
const bg = loadBackground();
|
||||
const page = bg.send(
|
||||
{
|
||||
type: "AUTISTMASK_RPC",
|
||||
method: "eth_sign",
|
||||
params: [signer.address, MESSAGE],
|
||||
},
|
||||
{ origin: ORIGIN },
|
||||
);
|
||||
await settle();
|
||||
const id = approvalIdIn(bg.created.map((c) => c.url));
|
||||
|
||||
const details = bg.send(
|
||||
{ type: "AUTISTMASK_GET_APPROVAL", id },
|
||||
{ url: bg.fromPopup.url },
|
||||
);
|
||||
const { signParams } = details.sendResponse.mock.calls[0][0];
|
||||
expect(signParams).toMatchObject({
|
||||
method: "eth_sign",
|
||||
message: MESSAGE,
|
||||
from: signer.address,
|
||||
});
|
||||
expect(signParams.dangerWarning).toBe(
|
||||
"This site used the older eth_sign method. " +
|
||||
"The data will be signed as a personal message.",
|
||||
);
|
||||
|
||||
const signature = await signer.signMessage(
|
||||
Buffer.from(MESSAGE.slice(2), "hex"),
|
||||
);
|
||||
bg.send(
|
||||
{ type: "AUTISTMASK_SIGN_RESPONSE", id, approved: true, signature },
|
||||
{ url: bg.fromPopup.url },
|
||||
);
|
||||
await settle();
|
||||
|
||||
expect(page.sendResponse).toHaveBeenCalledWith({ result: signature });
|
||||
});
|
||||
});
|
||||
|
||||
// The interlock must not cost the retry the approval exists to allow.
|
||||
describe("the interlock releases a failed attempt", () => {
|
||||
test("a retryable failure before the broadcast leaves the approval usable", async () => {
|
||||
@@ -2854,7 +2805,7 @@ describe("where an approval window opens", () => {
|
||||
await settle();
|
||||
|
||||
expect(bg.created).toHaveLength(1);
|
||||
expect(bg.created[0]).toMatchObject({ left: 460, top: 60 });
|
||||
expect(bg.created[0]).toMatchObject({ left: 442, top: 60 });
|
||||
});
|
||||
|
||||
test("not centred on an approval window the user was last in", async () => {
|
||||
@@ -2871,7 +2822,7 @@ describe("where an approval window opens", () => {
|
||||
bg.requestSign();
|
||||
await settle();
|
||||
|
||||
// Centred, it would be at left 900, the position the browser refused.
|
||||
// Centred, it would be at left 882, the position the browser refused.
|
||||
expect(bg.created).toHaveLength(1);
|
||||
expect(bg.created[0].left).toBeUndefined();
|
||||
expect(bg.created[0].top).toBeUndefined();
|
||||
@@ -2893,7 +2844,7 @@ describe("where an approval window opens", () => {
|
||||
await settle();
|
||||
|
||||
expect(bg.created).toHaveLength(2);
|
||||
expect(bg.created[0]).toMatchObject({ left: 1520, top: 750 });
|
||||
expect(bg.created[0]).toMatchObject({ left: 1502, top: 750 });
|
||||
expect(bg.created[1].left).toBeUndefined();
|
||||
expect(bg.created[1].top).toBeUndefined();
|
||||
|
||||
|
||||
@@ -1,259 +0,0 @@
|
||||
// A transfer is sent only on the network its confirmation screen was drawn for
|
||||
// (https://git.eeqj.de/sneak/AutistMask/issues/524).
|
||||
//
|
||||
// Settings is reachable from the confirmation screen, and Back from it only
|
||||
// unhides the screen, still labelled for the network it was drawn for. Sign &
|
||||
// Send used to take the network at the moment of the click, so 1 SepoliaETH
|
||||
// reviewed on Sepolia went out as 1 ETH on mainnet once mainnet was chosen in
|
||||
// Settings in between.
|
||||
//
|
||||
// Driven through the real confirmation screen, signer and chain switch, with
|
||||
// only the node and the DOM stubbed. The stub node is on the network its
|
||||
// provider was built for, so a broadcast records the network it went to.
|
||||
|
||||
"use strict";
|
||||
|
||||
// The signed transactions the stub node was handed, with its network's chain id.
|
||||
const mockNode = { broadcast: [] };
|
||||
|
||||
jest.mock("ethers", () => {
|
||||
const actual = jest.requireActual("ethers");
|
||||
class StubProvider {
|
||||
constructor(url, network) {
|
||||
this.network = network;
|
||||
}
|
||||
async getNetwork() {
|
||||
return this.network;
|
||||
}
|
||||
async getFeeData() {
|
||||
return {
|
||||
maxFeePerGas: 20000000000n,
|
||||
maxPriorityFeePerGas: 1000000000n,
|
||||
gasPrice: 10000000000n,
|
||||
};
|
||||
}
|
||||
async estimateGas() {
|
||||
return 21000n;
|
||||
}
|
||||
async getCode() {
|
||||
return "0x";
|
||||
}
|
||||
async getTransactionCount() {
|
||||
return 1;
|
||||
}
|
||||
async lookupAddress() {
|
||||
return null;
|
||||
}
|
||||
async broadcastTransaction(signed) {
|
||||
mockNode.broadcast.push({ chainId: this.network.chainId, signed });
|
||||
return { hash: "0x" + "ab".repeat(32) };
|
||||
}
|
||||
}
|
||||
return { ...actual, JsonRpcProvider: StubProvider };
|
||||
});
|
||||
|
||||
jest.mock("../src/shared/log", () => ({
|
||||
log: {
|
||||
debugf: () => {},
|
||||
infof: () => {},
|
||||
warnf: () => {},
|
||||
errorf: () => {},
|
||||
},
|
||||
debugFetch: jest.fn(async () => ({
|
||||
ok: true,
|
||||
status: 200,
|
||||
json: async () => ({ items: [] }),
|
||||
})),
|
||||
urlOrigin: () => "",
|
||||
setRuntimeDebug: () => {},
|
||||
isDebug: () => false,
|
||||
}));
|
||||
|
||||
// The wait screen polls for a receipt; these tests stop at the broadcast.
|
||||
jest.mock("../src/popup/views/txStatus", () => ({
|
||||
showWait: jest.fn(),
|
||||
showError: jest.fn(),
|
||||
}));
|
||||
|
||||
global.fetch = jest.fn(() => {
|
||||
throw new Error("tests must not perform network requests");
|
||||
});
|
||||
|
||||
const { makeStorageStub } = require("./support/storageStub");
|
||||
global.chrome = { storage: makeStorageStub(), runtime: { sendMessage() {} } };
|
||||
|
||||
// A stub DOM: every id resolves to a recording element.
|
||||
const elements = new Map();
|
||||
|
||||
function makeEl(id) {
|
||||
const handlers = new Map();
|
||||
return {
|
||||
id,
|
||||
textContent: "",
|
||||
innerHTML: "",
|
||||
value: "",
|
||||
disabled: false,
|
||||
style: {},
|
||||
dataset: {},
|
||||
classList: {
|
||||
add() {},
|
||||
remove() {},
|
||||
toggle() {},
|
||||
contains: () => false,
|
||||
},
|
||||
handlers,
|
||||
addEventListener(name, fn) {
|
||||
handlers.set(name, fn);
|
||||
},
|
||||
querySelectorAll: () => [],
|
||||
querySelector: () => null,
|
||||
remove() {},
|
||||
focus() {},
|
||||
};
|
||||
}
|
||||
|
||||
global.document = {
|
||||
getElementById(id) {
|
||||
if (!elements.has(id)) elements.set(id, makeEl(id));
|
||||
return elements.get(id);
|
||||
},
|
||||
createElement: (tag) => makeEl(tag),
|
||||
body: { prepend() {}, appendChild() {} },
|
||||
addEventListener() {},
|
||||
};
|
||||
global.navigator = { clipboard: { writeText() {} } };
|
||||
|
||||
const { BaseWallet, Transaction, Wallet } = require("ethers");
|
||||
const { encryptWithPassword } = require("../src/shared/vault");
|
||||
const { state, loadState } = require("../src/shared/state");
|
||||
const { onChainSwitch } = require("../src/shared/chainSwitch");
|
||||
const { NETWORKS } = require("../src/shared/networks");
|
||||
const txStatus = require("../src/popup/views/txStatus");
|
||||
const confirmTx = require("../src/popup/views/confirmTx");
|
||||
|
||||
const PRIVATE_KEY = "0x" + "11".repeat(32);
|
||||
const HOLDER = new Wallet(PRIVATE_KEY).address;
|
||||
const RECIPIENT = "0xC0FfEE0000000000000000000000000000c0fFEe";
|
||||
const PASSWORD = "correct horse battery staple";
|
||||
|
||||
function el(id) {
|
||||
return global.document.getElementById(id);
|
||||
}
|
||||
|
||||
let encryptedSecret;
|
||||
let signTransaction;
|
||||
|
||||
beforeAll(async () => {
|
||||
await loadState();
|
||||
encryptedSecret = await encryptWithPassword(PRIVATE_KEY, PASSWORD);
|
||||
});
|
||||
|
||||
beforeEach(() => {
|
||||
elements.clear();
|
||||
mockNode.broadcast = [];
|
||||
txStatus.showWait.mockClear();
|
||||
txStatus.showError.mockClear();
|
||||
signTransaction = jest.spyOn(BaseWallet.prototype, "signTransaction");
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
signTransaction.mockRestore();
|
||||
});
|
||||
|
||||
// Show the confirmation screen for 1 of the native token on `networkId`, as
|
||||
// Review on the Send screen does, with its fee estimate settled.
|
||||
async function review(networkId) {
|
||||
await onChainSwitch(networkId);
|
||||
state.wallets = [
|
||||
{
|
||||
type: "key",
|
||||
name: "Wallet 1",
|
||||
encryptedSecret,
|
||||
addresses: [{ address: HOLDER, balance: "5.0" }],
|
||||
},
|
||||
];
|
||||
state.selectedWallet = 0;
|
||||
state.selectedAddress = 0;
|
||||
confirmTx.init({});
|
||||
confirmTx.show({
|
||||
from: HOLDER,
|
||||
to: RECIPIENT,
|
||||
ensName: null,
|
||||
amount: "1",
|
||||
token: "ETH",
|
||||
balance: "5.0",
|
||||
tokenSymbol: null,
|
||||
tokenBalance: null,
|
||||
tokenDecimals: null,
|
||||
max: false,
|
||||
});
|
||||
for (let i = 0; i < 10; i++) await new Promise((r) => setTimeout(r, 0));
|
||||
}
|
||||
|
||||
async function signAndSend() {
|
||||
el("confirm-tx-password").value = PASSWORD;
|
||||
await el("btn-confirm-send").handlers.get("click")();
|
||||
}
|
||||
|
||||
test("a transfer reviewed on Sepolia and sent goes out on Sepolia", async () => {
|
||||
await review("sepolia");
|
||||
expect(el("confirm-type").textContent).toBe("Native SepoliaETH transfer");
|
||||
expect(el("btn-confirm-send").disabled).toBe(false);
|
||||
await signAndSend();
|
||||
expect(mockNode.broadcast).toHaveLength(1);
|
||||
expect(mockNode.broadcast[0].chainId).toBe(11155111n);
|
||||
expect(Transaction.from(mockNode.broadcast[0].signed).chainId).toBe(
|
||||
11155111n,
|
||||
);
|
||||
expect(txStatus.showWait).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
describe.each([
|
||||
["sepolia", "mainnet", "SepoliaETH"],
|
||||
["mainnet", "sepolia", "ETH"],
|
||||
])(
|
||||
"a transfer reviewed on %s, with %s chosen in Settings before Sign & Send",
|
||||
(reviewedOn, switchedTo, symbol) => {
|
||||
test("is neither signed nor sent, and the screen says why", async () => {
|
||||
await review(reviewedOn);
|
||||
expect(el("confirm-type").textContent).toBe(
|
||||
"Native " + symbol + " transfer",
|
||||
);
|
||||
// Settings' network select, then Back, which only unhides the
|
||||
// screen as it was drawn.
|
||||
await onChainSwitch(switchedTo);
|
||||
await signAndSend();
|
||||
|
||||
expect(signTransaction).not.toHaveBeenCalled();
|
||||
expect(mockNode.broadcast).toEqual([]);
|
||||
expect(txStatus.showWait).not.toHaveBeenCalled();
|
||||
expect(txStatus.showError).not.toHaveBeenCalled();
|
||||
expect(el("confirm-errors").style.visibility).toBe("visible");
|
||||
expect(el("confirm-errors").innerHTML).toContain(
|
||||
"The active network changed after this transaction was" +
|
||||
" reviewed, so it was not sent. Please go back and review" +
|
||||
" it again.",
|
||||
);
|
||||
});
|
||||
},
|
||||
);
|
||||
|
||||
// The check in the click handler tells the user; the send itself carries the
|
||||
// chain id the screen was drawn for, so a signer on another network's node
|
||||
// cannot sign it even if the network changes after that check.
|
||||
test("the send is refused by a signer on another network's node", async () => {
|
||||
const { getProvider } = require("../src/shared/balances");
|
||||
const signer = new Wallet(PRIVATE_KEY).connect(
|
||||
getProvider("https://rpc.example.invalid", "mainnet"),
|
||||
);
|
||||
await expect(
|
||||
confirmTx.populateVerifyAndSend(signer, {
|
||||
token: "ETH",
|
||||
to: RECIPIENT,
|
||||
amount: "1",
|
||||
chainId: NETWORKS.sepolia.chainId,
|
||||
}),
|
||||
).rejects.toThrow("transaction chainId mismatch");
|
||||
expect(signTransaction).not.toHaveBeenCalled();
|
||||
expect(mockNode.broadcast).toEqual([]);
|
||||
});
|
||||
@@ -640,6 +640,19 @@ step(
|
||||
await d.switchToWindow(popup);
|
||||
await d.waitVisible("#view-approve-sign");
|
||||
|
||||
// The window is opened as wide as the page
|
||||
// (https://git.eeqj.de/sneak/AutistMask/issues/518). This suite is
|
||||
// where that is checked: the Chrome suite's approval windows open at
|
||||
// 1280x720 whatever width the extension asks for.
|
||||
const sideways = await d.execute(
|
||||
"return document.documentElement.scrollWidth -" +
|
||||
" document.documentElement.clientWidth;",
|
||||
);
|
||||
assert(
|
||||
sideways <= 0,
|
||||
"the sign prompt scrolls sideways by " + sideways + "px",
|
||||
);
|
||||
|
||||
const screen = await d.execute(
|
||||
`return {
|
||||
origin: document.getElementById("approve-sign-origin").textContent,
|
||||
|
||||
@@ -1,102 +0,0 @@
|
||||
// The sign screen signs an eth_sign request the way it signs personal_sign: as
|
||||
// an EIP-191 personal message over the bytes of the data
|
||||
// (https://git.eeqj.de/sneak/AutistMask/issues/409). Booted through the real
|
||||
// popup entry point as the approval window. The background's half, which reads
|
||||
// the address first and the data second and checks the signature, is tested in
|
||||
// tests/backgroundApproval.test.js.
|
||||
|
||||
// Mocked so that no password has to be hashed: the stored secret decrypts to
|
||||
// the test key below.
|
||||
jest.mock("../src/shared/vault", () => ({
|
||||
decryptWithPassword: jest.fn(),
|
||||
encryptWithPassword: jest.fn(),
|
||||
}));
|
||||
|
||||
const { Wallet, getBytes } = require("ethers");
|
||||
const {
|
||||
bootPopup,
|
||||
cleanupPopup,
|
||||
unversionedValidProfile,
|
||||
} = require("./support/popupBoot");
|
||||
|
||||
// A published test key, never used for real funds.
|
||||
const SIGNER_KEY =
|
||||
"0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d";
|
||||
const signer = new Wallet(SIGNER_KEY);
|
||||
// "Hello AutistMask", as the hex a page sends.
|
||||
const MESSAGE = "0x48656c6c6f204175746973744d61736b";
|
||||
const ORIGIN = "https://dapp.example";
|
||||
|
||||
afterEach(cleanupPopup);
|
||||
|
||||
test("the sign screen answers eth_sign with a personal message signature over the data", async () => {
|
||||
const sent = [];
|
||||
const page = await bootPopup(
|
||||
unversionedValidProfile({
|
||||
wallets: [
|
||||
{
|
||||
type: "key",
|
||||
name: "Wallet 1",
|
||||
encryptedSecret: "encrypted-key",
|
||||
addresses: [
|
||||
{
|
||||
address: signer.address,
|
||||
balance: "0.0000",
|
||||
tokenBalances: [],
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
activeAddress: signer.address,
|
||||
allowedSites: { [signer.address]: [ORIGIN] },
|
||||
}),
|
||||
{
|
||||
search: "?approval=approval-1",
|
||||
runtime: {
|
||||
connect: () => ({ postMessage: () => {} }),
|
||||
// Answered as the background answers: with the eth_sign
|
||||
// approval this window was opened for, and by handing back
|
||||
// the signature the popup sends.
|
||||
sendMessage: (msg, reply) => {
|
||||
sent.push(msg);
|
||||
if (msg.type === "AUTISTMASK_GET_APPROVAL") {
|
||||
reply({
|
||||
type: "sign",
|
||||
origin: ORIGIN,
|
||||
isPhishingDomain: false,
|
||||
approvedFrom: signer.address,
|
||||
signParams: {
|
||||
method: "eth_sign",
|
||||
message: MESSAGE,
|
||||
from: signer.address,
|
||||
},
|
||||
});
|
||||
} else if (msg.type === "AUTISTMASK_SIGN_RESPONSE") {
|
||||
reply({ signature: msg.signature });
|
||||
} else {
|
||||
reply(undefined);
|
||||
}
|
||||
},
|
||||
},
|
||||
},
|
||||
);
|
||||
globalThis.window.close = jest.fn();
|
||||
const { decryptWithPassword } = require("../src/shared/vault");
|
||||
decryptWithPassword.mockResolvedValue(SIGNER_KEY);
|
||||
|
||||
expect(page.visibleViews()).toEqual(["approve-sign"]);
|
||||
page.node("approve-sign-password").value = "any password";
|
||||
await page.click("btn-approve-sign");
|
||||
|
||||
expect(
|
||||
sent.filter((msg) => msg.type === "AUTISTMASK_SIGN_RESPONSE"),
|
||||
).toEqual([
|
||||
{
|
||||
type: "AUTISTMASK_SIGN_RESPONSE",
|
||||
id: "approval-1",
|
||||
approved: true,
|
||||
signature: await signer.signMessage(getBytes(MESSAGE)),
|
||||
},
|
||||
]);
|
||||
expect(globalThis.window.close).toHaveBeenCalled();
|
||||
});
|
||||
@@ -242,6 +242,11 @@ async function settle() {
|
||||
* "?approval=" and an id for the popup opened as an approval window.
|
||||
* @param {object} [options.runtime] members of chrome.runtime that replace the
|
||||
* stub's own, for a test that has to answer the background's messages.
|
||||
* @param {object} [options.windows] chrome.windows, for a test of the approval
|
||||
* window resizing itself.
|
||||
* @param {object} [options.documentElement] members of document.documentElement
|
||||
* that replace the stub's own: scrollWidth and clientWidth, which are equal
|
||||
* unless a test says otherwise, so the page does not scroll sideways.
|
||||
* @returns {Promise<object>} handles onto the booted page.
|
||||
*/
|
||||
async function bootPopup(stored, options) {
|
||||
@@ -277,6 +282,11 @@ async function bootPopup(stored, options) {
|
||||
(options && options.storage) ||
|
||||
makeStorageStub(stored === undefined ? {} : { autistmask: stored });
|
||||
const document = makeDocument(POPUP_HTML);
|
||||
Object.assign(
|
||||
document.documentElement,
|
||||
{ scrollWidth: 396, clientWidth: 396 },
|
||||
options && options.documentElement,
|
||||
);
|
||||
const reloads = [];
|
||||
|
||||
globalThis.chrome = {
|
||||
@@ -287,6 +297,7 @@ async function bootPopup(stored, options) {
|
||||
onMessage: { addListener: () => {} },
|
||||
...(options && options.runtime),
|
||||
},
|
||||
windows: options && options.windows,
|
||||
};
|
||||
globalThis.document = document;
|
||||
globalThis.window = {
|
||||
|
||||
@@ -1,176 +0,0 @@
|
||||
// The decoded details on the transaction detail screen of a token transfer
|
||||
// (https://git.eeqj.de/sneak/AutistMask/issues/515).
|
||||
//
|
||||
// A history row for a token transfer holds the transfer's recipient as its
|
||||
// `to`, not the contract the transaction was sent to. The screen used to decode
|
||||
// the transaction's data against that `to`, so its Token line named the
|
||||
// recipient, and the amount read "decimals unknown" for a token the wallet
|
||||
// tracks. It decodes against the address the explorer reports the transaction
|
||||
// was sent to.
|
||||
//
|
||||
// The row is the one the real history parser makes from the explorer's answer,
|
||||
// opened through transactionDetail.show(), which is what a click on the row
|
||||
// calls. Driven against a minimal DOM stub in the shape
|
||||
// tests/contractCreation.test.js uses.
|
||||
|
||||
const { Interface } = require("ethers");
|
||||
|
||||
jest.mock("../src/shared/log", () => ({
|
||||
log: {
|
||||
debugf: () => {},
|
||||
infof: () => {},
|
||||
warnf: () => {},
|
||||
errorf: () => {},
|
||||
},
|
||||
debugFetch: async (url) => ({
|
||||
ok: true,
|
||||
json: async () => mockExplorerAnswer(url),
|
||||
}),
|
||||
setRuntimeDebug: () => {},
|
||||
isDebug: () => false,
|
||||
}));
|
||||
|
||||
globalThis.chrome = {
|
||||
storage: { local: { get: async () => ({}), set: async () => {} } },
|
||||
};
|
||||
|
||||
const { state } = require("../src/shared/state");
|
||||
const { fetchRecentTransactions } = require("../src/shared/transactions");
|
||||
const transactionDetail = require("../src/popup/views/transactionDetail");
|
||||
|
||||
const EXPLORER = "https://explorer.example/api/v2";
|
||||
const HOLDER = "0x0000000000000000000000000000000000000a11";
|
||||
const RECIPIENT = "0x711e691962E5c054b78071C789A0C8CE657377aD";
|
||||
// A token the wallet tracks and the bundled token list does not name.
|
||||
const TOKEN = "0x74de5d4FCbf63E00296fd95d33236B9794016631";
|
||||
const TX_HASH =
|
||||
"0x85215772ed26ea8b39c2b3b18779030487efbe0b5fd7e882592b2f62b837be84";
|
||||
|
||||
// HOLDER sends 1234.5 of the 6-decimal token to RECIPIENT.
|
||||
const TRANSFER_DATA = new Interface([
|
||||
"function transfer(address to, uint256 amount)",
|
||||
]).encodeFunctionData("transfer", [RECIPIENT, 1234500000n]);
|
||||
|
||||
// The explorer's answers: the transfer in HOLDER's token transfers, and the
|
||||
// transaction itself, sent to the token contract.
|
||||
function mockExplorerAnswer(url) {
|
||||
if (
|
||||
url ===
|
||||
EXPLORER + "/addresses/" + HOLDER + "/token-transfers?type=ERC-20"
|
||||
) {
|
||||
return {
|
||||
items: [
|
||||
{
|
||||
transaction_hash: TX_HASH,
|
||||
block_number: 100,
|
||||
timestamp: "2026-10-01T00:00:00Z",
|
||||
from: { hash: HOLDER },
|
||||
to: { hash: RECIPIENT },
|
||||
total: { value: "1234500000", decimals: "6" },
|
||||
token: {
|
||||
address_hash: TOKEN,
|
||||
symbol: "TDOL",
|
||||
holders_count: "5000",
|
||||
},
|
||||
},
|
||||
],
|
||||
};
|
||||
}
|
||||
if (url === EXPLORER + "/transactions/" + TX_HASH) {
|
||||
return { to: { hash: TOKEN }, raw_input: TRANSFER_DATA };
|
||||
}
|
||||
return { items: [] };
|
||||
}
|
||||
|
||||
function makeElement(id) {
|
||||
const classes = new Set();
|
||||
const el = {
|
||||
id,
|
||||
textContent: "",
|
||||
value: "",
|
||||
innerHTML: "",
|
||||
style: {},
|
||||
dataset: {},
|
||||
classList: {
|
||||
add: (...names) => names.forEach((n) => classes.add(n)),
|
||||
remove: (...names) => names.forEach((n) => classes.delete(n)),
|
||||
contains: (n) => classes.has(n),
|
||||
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"),
|
||||
body: { prepend: () => {} },
|
||||
};
|
||||
}
|
||||
|
||||
function node(id) {
|
||||
return globalThis.document.getElementById(id);
|
||||
}
|
||||
|
||||
// One line of the decoded details: its label and what is drawn under it.
|
||||
function decodedLine(label) {
|
||||
return node("tx-detail-calldata-details")
|
||||
.innerHTML.split('<div class="mb-2">')
|
||||
.find((line) =>
|
||||
line.startsWith(`<div class="text-muted">${label}</div>`),
|
||||
);
|
||||
}
|
||||
|
||||
beforeEach(() => {
|
||||
globalThis.document = makeDocument();
|
||||
globalThis.window = { location: { search: "" } };
|
||||
state.blockscoutUrl = EXPLORER;
|
||||
state.wallets = [
|
||||
{
|
||||
name: "Main",
|
||||
type: "key",
|
||||
addresses: [{ address: HOLDER, balance: "0.0000" }],
|
||||
},
|
||||
];
|
||||
state.trackedTokens = [{ address: TOKEN, symbol: "TDOL", decimals: 6 }];
|
||||
state.viewData = {};
|
||||
state.viewStack = [];
|
||||
state.currentView = null;
|
||||
});
|
||||
|
||||
test("a token transfer's decoded details name the token contract and the amount at its scale", async () => {
|
||||
const [row] = await fetchRecentTransactions(HOLDER, EXPLORER, 1);
|
||||
expect(row.to).toBe(RECIPIENT);
|
||||
expect(row.contractAddress).toBe(TOKEN.toLowerCase());
|
||||
|
||||
transactionDetail.show(row);
|
||||
// The decoded details are drawn once the explorer has answered.
|
||||
for (let i = 0; i < 10; i++) await new Promise((r) => setTimeout(r, 0));
|
||||
|
||||
expect(node("tx-detail-calldata-action").textContent).toBe(
|
||||
"Token Transfer",
|
||||
);
|
||||
const token = decodedLine("Token");
|
||||
expect(token).toContain('<div class="font-bold">TDOL</div>');
|
||||
expect(token).toContain(TOKEN);
|
||||
expect(token).not.toContain(RECIPIENT);
|
||||
expect(decodedLine("Recipient")).toContain(RECIPIENT);
|
||||
expect(decodedLine("Amount")).toContain(
|
||||
'<div class="font-bold">1234.5000 TDOL</div>',
|
||||
);
|
||||
});
|
||||
@@ -233,26 +233,6 @@ function warningOf(data) {
|
||||
return html.slice(0, html.indexOf(">Domain<"));
|
||||
}
|
||||
|
||||
const NOT_SIGNED = ">Not part of the signature<";
|
||||
|
||||
// The Message section alone, without the keys listed after it as not part of
|
||||
// the signature.
|
||||
function messageOf(data) {
|
||||
const html = formatTypedDataHtml(JSON.stringify(data));
|
||||
const end = html.indexOf(NOT_SIGNED);
|
||||
return html.slice(
|
||||
html.indexOf(">Message<"),
|
||||
end === -1 ? html.length : end,
|
||||
);
|
||||
}
|
||||
|
||||
// The keys listed as not part of the signature, or "" when there are none.
|
||||
function notSignedOf(data) {
|
||||
const html = formatTypedDataHtml(JSON.stringify(data));
|
||||
const start = html.indexOf(NOT_SIGNED);
|
||||
return start === -1 ? "" : html.slice(start);
|
||||
}
|
||||
|
||||
function request(data) {
|
||||
return { method: "eth_signTypedData_v4", typedData: JSON.stringify(data) };
|
||||
}
|
||||
@@ -332,8 +312,7 @@ describe("the warning reads only the fields the signed type declares", () => {
|
||||
});
|
||||
|
||||
// A Permit whose type names its spender `operator`; the page adds a
|
||||
// `spender` key the type does not declare. The Message section names
|
||||
// only the operator, and the added key is listed apart as not signed.
|
||||
// `spender` key the type does not declare.
|
||||
test("an added key is not named as the spender", () => {
|
||||
const data = {
|
||||
...PERMIT,
|
||||
@@ -352,10 +331,6 @@ describe("the warning reads only the fields the signed type declares", () => {
|
||||
const warning = warningOf(data);
|
||||
expect(warning).toContain(WARNING);
|
||||
expect(warning).not.toContain(DECOY);
|
||||
expect(messageOf(data)).toContain(SPENDER);
|
||||
expect(messageOf(data)).not.toContain(DECOY);
|
||||
expect(notSignedOf(data)).toContain("spender:");
|
||||
expect(notSignedOf(data)).toContain(DECOY);
|
||||
});
|
||||
|
||||
// The permit for a Uniswap v3 position NFT: a `Permit` with no amount
|
||||
@@ -396,47 +371,6 @@ describe("the warning reads only the fields the signed type declares", () => {
|
||||
});
|
||||
});
|
||||
|
||||
// ethers signs only the declared fields at every level of nesting, so an
|
||||
// added key inside a struct is not signed either. Such typed data is not
|
||||
// refused; the added key is listed apart, with where it sits in the message.
|
||||
describe("the Message section shows only the fields that are signed", () => {
|
||||
const NOTE = "This signature only signs you in";
|
||||
|
||||
test("an added key inside a nested struct is listed as not signed", () => {
|
||||
const data = {
|
||||
...PERMIT_SINGLE,
|
||||
message: {
|
||||
...PERMIT_SINGLE.message,
|
||||
details: { ...PERMIT_SINGLE.message.details, note: NOTE },
|
||||
},
|
||||
};
|
||||
expect(messageOf(data)).toContain("expiration");
|
||||
expect(messageOf(data)).not.toContain(NOTE);
|
||||
expect(notSignedOf(data)).toContain("details.note:");
|
||||
expect(notSignedOf(data)).toContain(NOTE);
|
||||
expect(typedDataRefusal(request(data))).toBeNull();
|
||||
});
|
||||
|
||||
test("an added key inside a list item is listed with its index", () => {
|
||||
const [first, second] = PERMIT_BATCH.message.details;
|
||||
const data = {
|
||||
...PERMIT_BATCH,
|
||||
message: {
|
||||
...PERMIT_BATCH.message,
|
||||
details: [first, { ...second, note: NOTE }],
|
||||
},
|
||||
};
|
||||
expect(messageOf(data)).not.toContain(NOTE);
|
||||
expect(notSignedOf(data)).toContain("details[1].note:");
|
||||
expect(notSignedOf(data)).toContain(NOTE);
|
||||
});
|
||||
|
||||
test("nothing is listed apart when every key is declared", () => {
|
||||
expect(notSignedOf(PERMIT_SINGLE)).toBe("");
|
||||
expect(notSignedOf(LOGIN)).toBe("");
|
||||
});
|
||||
});
|
||||
|
||||
describe("the primary type shown is the one ethers signs", () => {
|
||||
// A drain stated as a sign-in: the page says Login, the types say
|
||||
// PermitSingle, and ethers would sign PermitSingle.
|
||||
|
||||
Reference in New Issue
Block a user