sneak/AutistMask
0
0
Fork 0
Code Issues 15 Pull Requests 8 Actions 108 Packages Projects Releases Wiki Activity

fix: a split swap's Min. received is the sum of its steps' minimums (closes #647)
check / check (push) Waiting to run
Details
e2e / e2e-chrome (push) Waiting to run
Details
e2e / e2e-firefox (push) Waiting to run
Details

Browse Source 
The step that sets the output side gives the minimum. When that step
and earlier swap steps each pay the output token to the sender, the
minimum is now the sum of their minimums. There is no figure when the
decoder reads none from one of them, or when one of them pays part of
that token elsewhere. There is also none when the decoder did not read
one of them, or a step between them, in full.

These steps drop earlier steps from the sum, so a multi-hop route reads
as before:

- a V2 or V3 swap step that spends the output token;
- a V4 step with a swap action that spends that token, or with a SETTLE
  or SETTLE_ALL of that token;
- a PERMIT2_TRANSFER_FROM of that token.

Model: opus-5-5
This commit is contained in:
sneak
2026-10-27 09:24:40 +00:00
parent c0a3a02418
commit a0cde7987b
3 changed files with 387 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/shared/uniswap.js
+109 -11
View File
@@ -988,6 +988,9 @@ function totalAmount(amounts) {
// pays it of Token In as the step's amount in place of the rules' Amount, or
// no amount when this decoder cannot tell what that is.
//
// `spent` lists the currency that each swap action spends, for each swap
// action that this decoder could read.
//
// `takes` is every TAKE, TAKE_ALL and TAKE_PORTION, as the currency it takes
// and its recipient as written, MSG_SENDER for a TAKE_ALL. TAKE_PORTION takes
// a share of the currency, so it does not name the output side as TAKE does.
@@ -1163,6 +1166,8 @@ function decodeV4Swap(input) {
}
}
const spent = swaps.map((s) => s.tokenIn);
// Rule 3.
if (swapUndecoded) {
return {
@@ -1170,6 +1175,7 @@ function decodeV4Swap(input) {
tokenOut: takeToken,
amountIn: null,
amountOutMin: null,
spent,
takes,
settledFromRouter,
paidByUser,
@@ -1180,7 +1186,6 @@ function decodeV4Swap(input) {
};
}
const spent = swaps.map((s) => s.tokenIn);
const bought = swaps.map((s) => s.tokenOut);
// Rules 1 and 2 for Token In.
@@ -1216,6 +1221,7 @@ function decodeV4Swap(input) {
tokenOut,
amountIn,
amountOutMin,
spent,
takes,
settledFromRouter,
paidByUser,
@@ -1307,8 +1313,9 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
const commandNames = [];
// THE INVARIANT: an amount and the token it is counted in always come
// from the same hop, or from hops that all spend that token. A figure
// is never rendered against a token that did not supply it.
// from the same hop, or from hops that all spend that token or all buy
// it. A figure is never rendered against a token that did not supply
// it.
//
// Both sides are therefore set as a PAIR — never field by field, and
// never on truthiness. An address is never falsy once set but an
@@ -1423,6 +1430,10 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
const r = recipient.toLowerCase();
return r === ADDRESS_THIS || r === toAddress.toLowerCase();
};
const isSender = (recipient) => {
const r = recipient.toLowerCase();
return r === MSG_SENDER || r === sender;
};
// A swap step or V4 SETTLE pays `amount` of `token` from the router's
// own balance. CONTRACT_BALANCE pays all of it. Any other quantity
// counts against the amount a WRAP_ETH stated, and the steps pay all
@@ -1455,17 +1466,69 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
// A step pays `recipient`. `output` is the token a swap step or a V4
// TAKE or TAKE_PORTION pays; other steps pass none.
const addPayee = (recipient, output) => {
const r = recipient.toLowerCase();
if (isRouter(recipient)) {
if (present(output)) {
heldByRouter.set(output.toLowerCase(), null);
}
} else if (r === MSG_SENDER || r === sender) {
} else if (isSender(recipient)) {
paidToSender = true;
} else {
addPaidElsewhere(recipient);
}
};
// Each swap step that paid the sender some of the token it bought,
// as { step, token, amount, onlyToSender }: the step's index, that
// token, the step's stated minimum, and 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. These steps spend a token:
// - a V2 or V3 swap step spends its input token;
// - a V4 step spends each token that one of its swap actions spends,
// and each token that one of its SETTLEs or SETTLE_ALLs pays;
// - a PERMIT2_TRANSFER_FROM spends the token it moves.
const dropFromSum = (token) => {
swapsPayingSender = swapsPayingSender.filter(
(s) => !sameAddress(s.token, token),
);
};
// The minimum the output side shows for the swap step at `step`. The
// step buys `token` with the stated minimum `amount`, and pays
// `token` to `recipients`. The minimum is the step's own, unless this
// step and an earlier one on swapsPayingSender both pay `token` to
// the sender, as a route split across steps does. The minimum is then
// the total of all such steps' minimums. There is none when this
// decoder reads no minimum from one of them, or when one of them pays
// some of `token` elsewhere. There is also none when this decoder did
// not read one of them, or a step between them, in full (see
// stepsUnread).
const swapMinimum = (step, token, amount, recipients) => {
const toSender = recipients.filter(
(r) => present(r) && isSender(r),
);
if (toSender.length === 0) return amount;
swapsPayingSender.push({
step,
token,
amount,
onlyToSender: toSender.length === recipients.length,
});
const split = swapsPayingSender.filter((s) =>
sameAddress(s.token, token),
);
if (split.length < 2) return amount;
if (
split.some(
(s) => !s.onlyToSender || typeof s.amount !== "bigint",
) ||
stepsUnread.some((unread) => unread >= split[0].step)
) {
return null;
}
return split.reduce((sum, s) => sum + s.amount, 0n);
};
// A step that pays `token` to `recipient` is a hop, not a payout,
// when the very next step is a V2 exact-in whose input is already
// paid, whose path starts at `token`, and whose pair (see v2PairFor())
@@ -1607,6 +1670,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
: null,
});
}
if (p) dropFromSum(p.token);
} else if (command === "BALANCE_CHECK_ERC20") {
const b = decodeBalanceCheck(inputs[i]);
if (!b) {
@@ -1649,10 +1713,18 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
} else if (s.payerIsUser) {
addUserPaid(s.tokenIn, s.amountIn);
}
dropFromSum(s.tokenIn);
// Always update output: in multi-step swaps (V3 → V4),
// the last swap step determines the final output token
// and minimum received amount.
setOutput(i, s.tokenOut, s.amountOutMin, [s.recipient]);
// the last swap step determines the final output
// token. swapMinimum() gives the minimum.
setOutput(
i,
s.tokenOut,
swapMinimum(i, s.tokenOut, s.amountOutMin, [
s.recipient,
]),
[s.recipient],
);
if (!s.payerIsUser) {
spendFromRouter(s.tokenIn, s.amountIn);
}
@@ -1673,7 +1745,15 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
} else if (s.payerIsUser) {
addUserPaid(s.tokenIn, s.amountIn);
}
setOutput(i, s.tokenOut, s.amountOutMin, [s.recipient]);
dropFromSum(s.tokenIn);
setOutput(
i,
s.tokenOut,
swapMinimum(i, s.tokenOut, s.amountOutMin, [
s.recipient,
]),
[s.recipient],
);
if (!s.payerIsUser) {
spendFromRouter(s.tokenIn, s.amountIn);
}
@@ -1705,7 +1785,15 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
} else if (s.payerIsUser) {
addUserPaid(s.tokenIn, s.amountInMax);
}
setOutput(i, s.tokenOut, s.amountOut, [s.recipient]);
dropFromSum(s.tokenIn);
setOutput(
i,
s.tokenOut,
swapMinimum(i, s.tokenOut, s.amountOut, [
s.recipient,
]),
[s.recipient],
);
if (!isHop(i, s.tokenOut, s.recipient)) {
addPayee(s.recipient, s.tokenOut);
}
@@ -1877,6 +1965,11 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
addPayee(t.recipient, t.currency);
}
}
for (const token of v4.spent) dropFromSum(token);
for (const s of v4.paidByUser) dropFromSum(s.currency);
for (const s of v4.settledFromRouter) {
dropFromSum(s.currency);
}
}
if (!v4 || v4.recipientUnread) {
payeeUnread = true;
@@ -1925,7 +2018,12 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
setInput(v4.tokenIn, amountIn);
}
outputToken = v4.tokenOut;
minOutput = v4.amountOutMin;
minOutput = swapMinimum(
i,
v4.tokenOut,
v4.amountOutMin,
takeRecipients,
);
outputEstablished = true;
outputUnwrapped = false;
unwrapIntoRouterStep = null;