sneak
fde8d1cdf0
The fee estimate starts once the balance is read, and both it and the balance line took the active network at that moment, so a network switched in Settings while the read was in flight put a mainnet balance under a SepoliaETH label and estimated its fee on Sepolia. show() now builds the node of the network it is drawn for once and passes it to the balance read, the fee estimate and the recipient check, and every native symbol on the screen comes from the chain id it is drawn for. Model: opus-5-5
474 lines
16 KiB
JavaScript
474 lines
16 KiB
JavaScript
// 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.
|
|
//
|
|
// Its balance line and balance check are that network's too
|
|
// (https://git.eeqj.de/sneak/AutistMask/issues/558). The popup can reopen onto
|
|
// a confirmation screen saved before the network was switched in another
|
|
// popup, and the screen, drawn again for the new network, showed and checked
|
|
// the balance Send had read on the old one. The balance read and the fee
|
|
// estimate after it stay on that network when it is switched while they run.
|
|
//
|
|
// 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, and
|
|
// a balance read answers with that network's balance.
|
|
|
|
"use strict";
|
|
|
|
// The balances the stub node reports on each network, by network name: ETH
|
|
// in wei and the token in its base units. The networks whose node was asked
|
|
// for the fee, in order. And the signed transactions it was handed, with its
|
|
// network's chain id.
|
|
const mockNode = {
|
|
balanceWei: {},
|
|
tokenUnits: {},
|
|
feeAskedOn: [],
|
|
broadcast: [],
|
|
};
|
|
|
|
jest.mock("ethers", () => {
|
|
const actual = jest.requireActual("ethers");
|
|
// The selector of balanceOf(address).
|
|
const BALANCE_OF = "0x70a08231";
|
|
class StubProvider {
|
|
constructor(url, network) {
|
|
this.network = network;
|
|
}
|
|
async getNetwork() {
|
|
return this.network;
|
|
}
|
|
async getBalance() {
|
|
return mockNode.balanceWei[this.network.name];
|
|
}
|
|
// balanceOf() is the one contract call the screen makes before Sign
|
|
// & Send.
|
|
async call(tx) {
|
|
if (!tx.data.startsWith(BALANCE_OF)) {
|
|
throw new Error("the stub node answers only balanceOf()");
|
|
}
|
|
return actual.AbiCoder.defaultAbiCoder().encode(
|
|
["uint256"],
|
|
[mockNode.tokenUnits[this.network.name]],
|
|
);
|
|
}
|
|
async getFeeData() {
|
|
mockNode.feeAskedOn.push(this.network.name);
|
|
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,
|
|
JsonRpcProvider,
|
|
Transaction,
|
|
Wallet,
|
|
parseEther,
|
|
} = 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";
|
|
// A token with 6 decimal places, which the bundled list does not know.
|
|
const TOKEN = "0x" + "d".repeat(40);
|
|
|
|
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.balanceWei = {
|
|
mainnet: parseEther("5"),
|
|
sepolia: parseEther("5"),
|
|
};
|
|
mockNode.tokenUnits = { mainnet: 0n, sepolia: 0n };
|
|
mockNode.feeAskedOn = [];
|
|
mockNode.broadcast = [];
|
|
txStatus.showWait.mockClear();
|
|
txStatus.showError.mockClear();
|
|
signTransaction = jest.spyOn(BaseWallet.prototype, "signTransaction");
|
|
});
|
|
|
|
afterEach(() => {
|
|
signTransaction.mockRestore();
|
|
});
|
|
|
|
// show() reads the balances and estimates the fee without awaiting either;
|
|
// this lets both settle.
|
|
async function settle() {
|
|
for (let i = 0; i < 10; i++) await new Promise((r) => setTimeout(r, 0));
|
|
}
|
|
|
|
// Show the confirmation screen for 1 of the native token on `networkId`, or
|
|
// for what `send` describes instead, as Review on the Send screen does, with
|
|
// its balance read and its fee estimate settled.
|
|
async function review(networkId, send = {}) {
|
|
await onChainSwitch(networkId);
|
|
state.wallets = [
|
|
{
|
|
type: "key",
|
|
name: "Wallet 1",
|
|
encryptedSecret,
|
|
addresses: [{ address: HOLDER }],
|
|
},
|
|
];
|
|
state.selectedWallet = 0;
|
|
state.selectedAddress = 0;
|
|
confirmTx.init({});
|
|
confirmTx.show({
|
|
from: HOLDER,
|
|
to: RECIPIENT,
|
|
ensName: null,
|
|
amount: "1",
|
|
token: "ETH",
|
|
tokenSymbol: null,
|
|
tokenDecimals: null,
|
|
max: false,
|
|
...send,
|
|
});
|
|
await settle();
|
|
}
|
|
|
|
// Switch the network to `networkId` as Settings in another popup does, then
|
|
// open the popup again onto the confirmation screen it saved.
|
|
async function reopenOn(networkId) {
|
|
const saved = JSON.parse(JSON.stringify(state.viewData));
|
|
await onChainSwitch(networkId);
|
|
elements.clear();
|
|
state.viewData = saved;
|
|
confirmTx.init({});
|
|
confirmTx.restore();
|
|
await settle();
|
|
}
|
|
|
|
function errors() {
|
|
return el("confirm-errors").innerHTML;
|
|
}
|
|
|
|
function sendDisabled() {
|
|
return el("btn-confirm-send").disabled;
|
|
}
|
|
|
|
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([]);
|
|
});
|
|
|
|
describe("a confirmation screen saved on mainnet and reopened after a switch to Sepolia", () => {
|
|
test("states and checks the Sepolia balance, which covers the send", async () => {
|
|
mockNode.balanceWei = {
|
|
mainnet: parseEther("0.5"),
|
|
sepolia: parseEther("5"),
|
|
};
|
|
await review("mainnet");
|
|
expect(el("confirm-balance").textContent).toBe("0.5000 ETH");
|
|
expect(sendDisabled()).toBe(true);
|
|
|
|
await reopenOn("sepolia");
|
|
expect(el("confirm-type").textContent).toBe(
|
|
"Native SepoliaETH transfer",
|
|
);
|
|
expect(el("confirm-balance").textContent).toBe("5.0000 SepoliaETH");
|
|
expect(errors()).toBe("");
|
|
expect(el("confirm-amount-fee-error").style.visibility).toBe("hidden");
|
|
expect(sendDisabled()).toBe(false);
|
|
});
|
|
|
|
test("states and checks the Sepolia balance, which does not cover the send", async () => {
|
|
mockNode.balanceWei = {
|
|
mainnet: parseEther("5"),
|
|
sepolia: parseEther("0.5"),
|
|
};
|
|
await review("mainnet");
|
|
expect(el("confirm-balance").textContent).toBe("5.0000 ETH");
|
|
expect(sendDisabled()).toBe(false);
|
|
|
|
await reopenOn("sepolia");
|
|
expect(el("confirm-balance").textContent).toBe("0.5000 SepoliaETH");
|
|
expect(errors()).toContain(
|
|
"Insufficient balance. You have 0.5000 SepoliaETH but are trying" +
|
|
" to send 1 SepoliaETH.",
|
|
);
|
|
expect(sendDisabled()).toBe(true);
|
|
});
|
|
|
|
const tokenSend = {
|
|
token: TOKEN,
|
|
tokenSymbol: "TOK",
|
|
tokenDecimals: 6,
|
|
};
|
|
|
|
test("states and checks the Sepolia token balance, which covers the send", async () => {
|
|
mockNode.tokenUnits = { mainnet: 0n, sepolia: 10000000n };
|
|
await review("mainnet", tokenSend);
|
|
expect(el("confirm-balance").textContent).toBe("0.0000 TOK");
|
|
expect(sendDisabled()).toBe(true);
|
|
|
|
await reopenOn("sepolia");
|
|
expect(el("confirm-balance").textContent).toBe("10.0000 TOK");
|
|
expect(errors()).toBe("");
|
|
expect(el("confirm-gas-error").style.visibility).toBe("hidden");
|
|
expect(sendDisabled()).toBe(false);
|
|
});
|
|
|
|
test("states and checks the Sepolia token balance, which does not cover the send", async () => {
|
|
mockNode.tokenUnits = { mainnet: 10000000n, sepolia: 500000n };
|
|
await review("mainnet", tokenSend);
|
|
expect(el("confirm-balance").textContent).toBe("10.0000 TOK");
|
|
expect(sendDisabled()).toBe(false);
|
|
|
|
await reopenOn("sepolia");
|
|
expect(el("confirm-balance").textContent).toBe("0.5000 TOK");
|
|
expect(errors()).toContain(
|
|
"Insufficient TOK balance. You have 0.5000 TOK but are trying to" +
|
|
" send 1 TOK.",
|
|
);
|
|
expect(sendDisabled()).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe("the balance read", () => {
|
|
test("leaves the balance line Loading... and Sign & Send disabled until it returns", async () => {
|
|
let answer;
|
|
const getBalance = jest
|
|
.spyOn(JsonRpcProvider.prototype, "getBalance")
|
|
.mockImplementationOnce(() => new Promise((r) => (answer = r)));
|
|
try {
|
|
await review("sepolia");
|
|
} finally {
|
|
getBalance.mockRestore();
|
|
}
|
|
expect(el("confirm-balance").textContent).toBe("Loading...");
|
|
expect(el("confirm-fee-amount").textContent).toBe("Estimating...");
|
|
expect(el("confirm-errors").style.visibility).toBe("hidden");
|
|
expect(sendDisabled()).toBe(true);
|
|
|
|
answer(parseEther("5"));
|
|
await settle();
|
|
expect(el("confirm-balance").textContent).toBe("5.0000 SepoliaETH");
|
|
expect(sendDisabled()).toBe(false);
|
|
});
|
|
|
|
// The fee is estimated once the read returns, so a node chosen then would
|
|
// be the new network's.
|
|
test("still in flight when Sepolia is chosen in Settings leaves the balance and the fee on mainnet", async () => {
|
|
let answer;
|
|
const getBalance = jest
|
|
.spyOn(JsonRpcProvider.prototype, "getBalance")
|
|
.mockImplementationOnce(() => new Promise((r) => (answer = r)));
|
|
try {
|
|
await review("mainnet");
|
|
} finally {
|
|
getBalance.mockRestore();
|
|
}
|
|
expect(mockNode.feeAskedOn).toEqual([]);
|
|
|
|
await onChainSwitch("sepolia");
|
|
answer(parseEther("5"));
|
|
await settle();
|
|
|
|
expect(mockNode.feeAskedOn).toEqual(["mainnet"]);
|
|
expect(el("confirm-balance").textContent).toBe("5.0000 ETH");
|
|
// 21000 gas at 10 gwei expected, at 20 gwei reserved.
|
|
expect(el("confirm-fee-amount").textContent).toBe("~0.0002 ETH");
|
|
expect(el("confirm-fee-reserve").textContent).toBe(
|
|
"up to 0.0004 ETH reserved",
|
|
);
|
|
});
|
|
|
|
test("that fails states the balance as unknown, not zero, and blocks sending", async () => {
|
|
const getBalance = jest
|
|
.spyOn(JsonRpcProvider.prototype, "getBalance")
|
|
.mockRejectedValueOnce(new Error("the node did not answer"));
|
|
try {
|
|
await review("sepolia");
|
|
} finally {
|
|
getBalance.mockRestore();
|
|
}
|
|
expect(el("confirm-balance").textContent).toBe("unknown (SepoliaETH)");
|
|
expect(errors()).toBe(
|
|
'<div class="text-xs">Your balance could not be read from the' +
|
|
" network, so this transaction cannot be checked against it." +
|
|
" Please go back and try again.</div>",
|
|
);
|
|
expect(sendDisabled()).toBe(true);
|
|
});
|
|
});
|