fix: a swap split across steps the user pays for shows every amount it spends (closes #625)
The Amount line gave only the first swap step's amount. It now gives the total the steps take of Token In: the amount of the step that sets the input side plus each later take of it by a step the user pays. A V4 step, the first included, takes what its SETTLEs paid by the user state. A take of another token, one after an amount that is not a quantity, or one of unknown amount gets lines of its own. A step that may take what the decoder did not read gets one line saying so and leaves no figure. A PERMIT2_PERMIT names Token In; its amount stands only in the plain shape of Uniswap's own routes. Also closes #628. Model: opus-5-5
This commit is contained in:
+962
-2
@@ -1289,6 +1289,961 @@ describe("uniswap decoder", () => {
|
||||
expect(detail(result, "Amount").value).not.toContain("500000000000");
|
||||
});
|
||||
|
||||
// https://git.eeqj.de/sneak/AutistMask/issues/625 — a route split across
|
||||
// two swap steps the user pays for, with no PERMIT2_PERMIT, takes both
|
||||
// steps' amounts from the wallet. On next at 671b4d3 the Amount line read
|
||||
// only the first step's 600.0000 USDT.
|
||||
describe("a swap split across steps the user pays for", () => {
|
||||
const USDT_600 = 600000000n;
|
||||
const USDT_400 = 400000000n;
|
||||
const DAI_400 = 400000000000000000000n;
|
||||
const OTHER_ADDR = "0x1111111111111111111111111111111111111111";
|
||||
const UNDECODED = "Unknown (could not be decoded)";
|
||||
|
||||
// The lines between Token In and Token Out, as [label, value].
|
||||
function linesBetweenTokens(result) {
|
||||
const lines = result.details.map((d) => [d.label, d.value]);
|
||||
const from = lines.findIndex(([label]) => label === "Token In");
|
||||
const to = lines.findIndex(([label]) => label === "Token Out");
|
||||
return lines.slice(from + 1, to);
|
||||
}
|
||||
|
||||
// execute() of these command bytes and inputs, decoded as sent by
|
||||
// the user.
|
||||
function decodeSteps(commands, inputs) {
|
||||
const data = buildExecute(
|
||||
solidityPacked(
|
||||
commands.map(() => "uint8"),
|
||||
commands,
|
||||
),
|
||||
inputs,
|
||||
9999999999n,
|
||||
);
|
||||
return uniswap.decode(data, ROUTER_ADDR, "0x1", {}, USER_ADDR);
|
||||
}
|
||||
|
||||
// The first step: a V3 exact-in of 600 USDT for USDC, paid by the
|
||||
// user, which sets the input side.
|
||||
const V3_600 = encodeV3SwapExactIn(USER_ADDR, USDT_600, 590000000n, [
|
||||
USDT_ADDR,
|
||||
USDC_ADDR,
|
||||
]);
|
||||
// V4 SETTLE of `amount` of `currency`, and TAKE of `amount` of
|
||||
// `currency` to `recipient`.
|
||||
const settle = (currency, amount, payerIsUser) =>
|
||||
coder.encode(
|
||||
["address", "uint256", "bool"],
|
||||
[currency, amount, payerIsUser],
|
||||
);
|
||||
const take = (currency, recipient, amount) =>
|
||||
coder.encode(
|
||||
["address", "address", "uint256"],
|
||||
[currency, recipient, amount],
|
||||
);
|
||||
// `input` with the top byte of its word at `index` set. This decoder
|
||||
// cannot read such a word as an address or a length; the router reads
|
||||
// its low bytes and runs the step.
|
||||
const dirtyWord = (input, index) => {
|
||||
const at = 2 + index * 64;
|
||||
return input.slice(0, at) + "ff" + input.slice(at + 2);
|
||||
};
|
||||
|
||||
test("a split across a V3 and a V2 step the user pays for shows the total", () => {
|
||||
const data = buildExecute(
|
||||
solidityPacked(["uint8", "uint8"], [0x00, 0x08]),
|
||||
[
|
||||
encodeV3SwapExactIn(USER_ADDR, USDT_600, 590000000n, [
|
||||
USDT_ADDR,
|
||||
USDC_ADDR,
|
||||
]),
|
||||
encodeV2SwapExactIn(USER_ADDR, USDT_400, 390000000n, [
|
||||
USDT_ADDR,
|
||||
USDC_ADDR,
|
||||
]),
|
||||
],
|
||||
9999999999n,
|
||||
);
|
||||
|
||||
const result = uniswap.decode(
|
||||
data,
|
||||
ROUTER_ADDR,
|
||||
"0x1",
|
||||
{},
|
||||
USER_ADDR,
|
||||
);
|
||||
expect(result).not.toBeNull();
|
||||
|
||||
expect(detail(result, "Token In").address.toLowerCase()).toBe(
|
||||
USDT_ADDR.toLowerCase(),
|
||||
);
|
||||
expect(detail(result, "Amount").value).toBe("1000.0000 USDT");
|
||||
expect(detail(result, "Amount").rawValue).toBe("1000.0000");
|
||||
expect(detail(result, "Moved from the sender")).toBeUndefined();
|
||||
});
|
||||
|
||||
// In the order of Uniswap's own V4 routes: the swap, then a SETTLE of
|
||||
// OPEN_DELTA by the user, which pays what the swap spends.
|
||||
test("a split across a V3 step and a V4 step the user pays for shows the total", () => {
|
||||
const data = buildExecute(
|
||||
solidityPacked(["uint8", "uint8"], [0x00, 0x10]),
|
||||
[
|
||||
encodeV3SwapExactIn(USER_ADDR, USDT_600, 590000000n, [
|
||||
USDT_ADDR,
|
||||
USDC_ADDR,
|
||||
]),
|
||||
encodeV4Swap(
|
||||
new Uint8Array([
|
||||
V4_SWAP_EXACT_IN_SINGLE_ID,
|
||||
V4_SETTLE_ID,
|
||||
V4_TAKE_ID,
|
||||
]),
|
||||
[
|
||||
encodeV4ExactInSingle(
|
||||
USDT_ADDR,
|
||||
USDC_ADDR,
|
||||
USDT_400,
|
||||
390000000n,
|
||||
),
|
||||
encodeV4Settle(USDT_ADDR), // paid by the user
|
||||
encodeV4Take(USDC_ADDR),
|
||||
],
|
||||
),
|
||||
],
|
||||
9999999999n,
|
||||
);
|
||||
|
||||
const result = uniswap.decode(
|
||||
data,
|
||||
ROUTER_ADDR,
|
||||
"0x1",
|
||||
{},
|
||||
USER_ADDR,
|
||||
);
|
||||
expect(result).not.toBeNull();
|
||||
|
||||
expect(detail(result, "Amount").value).toBe("1000.0000 USDT");
|
||||
expect(detail(result, "Moved from the sender")).toBeUndefined();
|
||||
});
|
||||
|
||||
test("a second step the user pays for that spends another token shows that token's amount", () => {
|
||||
const data = buildExecute(
|
||||
solidityPacked(["uint8", "uint8"], [0x00, 0x08]),
|
||||
[
|
||||
encodeV3SwapExactIn(USER_ADDR, USDT_600, 590000000n, [
|
||||
USDT_ADDR,
|
||||
USDC_ADDR,
|
||||
]),
|
||||
encodeV2SwapExactIn(
|
||||
USER_ADDR,
|
||||
400000000000000000000n, // 400 DAI
|
||||
390000000n,
|
||||
[DAI_ADDR, USDC_ADDR],
|
||||
),
|
||||
],
|
||||
9999999999n,
|
||||
);
|
||||
|
||||
const result = uniswap.decode(
|
||||
data,
|
||||
ROUTER_ADDR,
|
||||
"0x1",
|
||||
{},
|
||||
USER_ADDR,
|
||||
);
|
||||
expect(result).not.toBeNull();
|
||||
|
||||
expect(linesBetweenTokens(result)).toEqual([
|
||||
["Amount", "600.0000 USDT"],
|
||||
["Moved from the sender", "400.0000 DAI"],
|
||||
["Token moved", "DAI (" + DAI_ADDR + ")"],
|
||||
["Moved to", "The swap step that spends it"],
|
||||
]);
|
||||
});
|
||||
|
||||
// Every later V4 step takes from the sender what its SETTLEs paid by
|
||||
// the user and its SETTLE_ALLs pay, each currency on its own, with a
|
||||
// swap action or without. Each of these read 600.0000 USDT alone
|
||||
// before.
|
||||
const USDT_FOR_USDC_400 = encodeV4ExactInSingle(
|
||||
USDT_ADDR,
|
||||
USDC_ADDR,
|
||||
USDT_400,
|
||||
390000000n,
|
||||
);
|
||||
const DAI_FOR_USDC_400 = encodeV4ExactInSingle(
|
||||
DAI_ADDR,
|
||||
USDC_ADDR,
|
||||
DAI_400,
|
||||
390000000n,
|
||||
);
|
||||
const DAI_GROUP = [
|
||||
["Moved from the sender", "400.0000 DAI"],
|
||||
["Token moved", "DAI (" + DAI_ADDR + ")"],
|
||||
["Moved to", "The swap step that spends it"],
|
||||
];
|
||||
test.each([
|
||||
{
|
||||
kind: "a V4 step paying USDT and DAI by a SETTLE_ALL of each",
|
||||
actions: [
|
||||
V4_SWAP_EXACT_IN_SINGLE_ID,
|
||||
V4_SWAP_EXACT_IN_SINGLE_ID,
|
||||
V4_SETTLE_ALL_ID,
|
||||
V4_SETTLE_ALL_ID,
|
||||
V4_TAKE_ALL_ID,
|
||||
],
|
||||
params: [
|
||||
USDT_FOR_USDC_400,
|
||||
DAI_FOR_USDC_400,
|
||||
encodeV4SettleAll(USDT_ADDR, USDT_400),
|
||||
encodeV4SettleAll(DAI_ADDR, DAI_400),
|
||||
encodeV4TakeAll(USDC_ADDR, 0n),
|
||||
],
|
||||
lines: [["Amount", "1000.0000 USDT"], ...DAI_GROUP],
|
||||
},
|
||||
{
|
||||
kind: "a V4 step with a SETTLE of USDT by the user, then a SETTLE of WETH from the router",
|
||||
actions: [
|
||||
V4_SETTLE_ID,
|
||||
V4_SETTLE_ID,
|
||||
V4_SWAP_EXACT_IN_SINGLE_ID,
|
||||
V4_SWAP_EXACT_IN_SINGLE_ID,
|
||||
V4_TAKE_ALL_ID,
|
||||
],
|
||||
params: [
|
||||
settle(USDT_ADDR, USDT_400, true),
|
||||
settle(WETH_ADDR, 2n ** 255n, false), // CONTRACT_BALANCE
|
||||
USDT_FOR_USDC_400,
|
||||
encodeV4ExactInSingle(WETH_ADDR, USDC_ADDR, 0n, 1n),
|
||||
encodeV4TakeAll(USDC_ADDR, 0n),
|
||||
],
|
||||
lines: [["Amount", "1000.0000 USDT"]],
|
||||
},
|
||||
{
|
||||
kind: "a V4 step with no swap action: a SETTLE of 400 USDT by the user and a TAKE of it to another address",
|
||||
actions: [V4_SETTLE_ID, V4_TAKE_ID],
|
||||
params: [
|
||||
settle(USDT_ADDR, USDT_400, true),
|
||||
take(USDT_ADDR, OTHER_ADDR, USDT_400),
|
||||
],
|
||||
lines: [["Amount", "1000.0000 USDT"]],
|
||||
},
|
||||
// The SETTLE's amount, not the swap's, is what the user pays.
|
||||
{
|
||||
kind: "a V4 step swapping 400 USDT with a SETTLE of 5,000 USDT by the user, the rest taken to another address",
|
||||
actions: [
|
||||
V4_SETTLE_ID,
|
||||
V4_SWAP_EXACT_IN_SINGLE_ID,
|
||||
V4_TAKE_ID,
|
||||
V4_TAKE_ALL_ID,
|
||||
],
|
||||
params: [
|
||||
settle(USDT_ADDR, 5000000000n, true),
|
||||
USDT_FOR_USDC_400,
|
||||
take(USDT_ADDR, OTHER_ADDR, 0n),
|
||||
encodeV4TakeAll(USDC_ADDR, 0n),
|
||||
],
|
||||
lines: [["Amount", "5600.0000 USDT"]],
|
||||
},
|
||||
// A SETTLE_ALL pays all the step owes, here what the TAKE takes as
|
||||
// well as what the swap spends, so its amount is not known.
|
||||
{
|
||||
kind: "a V4 step with no swap action: a TAKE of 400 USDT to another address, then a SETTLE_ALL of USDT",
|
||||
actions: [V4_TAKE_ID, V4_SETTLE_ALL_ID],
|
||||
params: [
|
||||
take(USDT_ADDR, OTHER_ADDR, USDT_400),
|
||||
encodeV4SettleAll(USDT_ADDR, USDT_400),
|
||||
],
|
||||
lines: [
|
||||
["Moved from the sender", UNDECODED],
|
||||
["Token moved", "USDT (" + USDT_ADDR + ")"],
|
||||
["Moved to", "The swap step that spends it"],
|
||||
],
|
||||
},
|
||||
{
|
||||
kind: "a V4 step swapping 400 USDT, with a TAKE of 400 USDT to another address before its SETTLE_ALL of USDT",
|
||||
actions: [
|
||||
V4_SWAP_EXACT_IN_SINGLE_ID,
|
||||
V4_TAKE_ID,
|
||||
V4_SETTLE_ALL_ID,
|
||||
V4_TAKE_ALL_ID,
|
||||
],
|
||||
params: [
|
||||
USDT_FOR_USDC_400,
|
||||
take(USDT_ADDR, OTHER_ADDR, USDT_400),
|
||||
encodeV4SettleAll(USDT_ADDR, 800000000n),
|
||||
encodeV4TakeAll(USDC_ADDR, 0n),
|
||||
],
|
||||
lines: [
|
||||
["Moved from the sender", UNDECODED],
|
||||
["Token moved", "USDT (" + USDT_ADDR + ")"],
|
||||
["Moved to", "The swap step that spends it"],
|
||||
],
|
||||
},
|
||||
])(
|
||||
"a V3 step of 600 USDT, then $kind",
|
||||
({ actions, params, lines }) => {
|
||||
const result = decodeSteps(
|
||||
[0x00, 0x10],
|
||||
[V3_600, encodeV4Swap(new Uint8Array(actions), params)],
|
||||
);
|
||||
expect(linesBetweenTokens(result)).toEqual(lines);
|
||||
},
|
||||
);
|
||||
|
||||
// https://git.eeqj.de/sneak/AutistMask/issues/628 — the V4 step that
|
||||
// sets the input side takes what its SETTLE paid by the user states,
|
||||
// not what its swap spends. Each of these read 400.0000 USDT before;
|
||||
// on next the first two read 400.0000 USDT and 1.0000 USDT.
|
||||
const V4_SETTLE_5000 = encodeV4Swap(
|
||||
new Uint8Array([
|
||||
V4_SETTLE_ID,
|
||||
V4_SWAP_EXACT_IN_SINGLE_ID,
|
||||
V4_TAKE_ID,
|
||||
V4_TAKE_ALL_ID,
|
||||
]),
|
||||
[
|
||||
settle(USDT_ADDR, 5000000000n, true),
|
||||
USDT_FOR_USDC_400,
|
||||
take(USDT_ADDR, OTHER_ADDR, 0n), // the rest
|
||||
encodeV4TakeAll(USDC_ADDR, 0n),
|
||||
],
|
||||
);
|
||||
test.each([
|
||||
{
|
||||
kind: "a V4 step swapping 400 USDT with a SETTLE of 5,000 USDT by the user, the rest taken to another address,",
|
||||
commands: [0x10],
|
||||
inputs: [V4_SETTLE_5000],
|
||||
},
|
||||
{
|
||||
kind: "a PERMIT2_PERMIT of 1 USDT that the router may let fail, then that V4 step,",
|
||||
commands: [0x8a, 0x10],
|
||||
inputs: [
|
||||
encodePermit2(USDT_ADDR, 1000000n, ROUTER_ADDR),
|
||||
V4_SETTLE_5000,
|
||||
],
|
||||
},
|
||||
// The unread SWEEP keeps the permit's amount from standing.
|
||||
{
|
||||
kind: "a PERMIT2_PERMIT of 5,000 USDT to the router, that V4 step, then a SWEEP that cannot be read,",
|
||||
commands: [0x0a, 0x10, 0x04],
|
||||
inputs: [
|
||||
encodePermit2(USDT_ADDR, 5000000000n, ROUTER_ADDR),
|
||||
V4_SETTLE_5000,
|
||||
dirtyWord(
|
||||
coder.encode(
|
||||
["address", "address", "uint256"],
|
||||
[USDC_ADDR, USER_ADDR, 0n],
|
||||
),
|
||||
1,
|
||||
),
|
||||
],
|
||||
},
|
||||
])("$kind shows the 5,000 USDT", ({ commands, inputs }) => {
|
||||
const result = decodeSteps(commands, inputs);
|
||||
expect(linesBetweenTokens(result)).toEqual([
|
||||
["Amount", "5000.0000 USDT"],
|
||||
]);
|
||||
});
|
||||
|
||||
// A step that may take from the sender what the decoder did not read
|
||||
// leaves no Amount figure, which may be too low, and one line says so.
|
||||
const UNREAD_SWAP = V4_SWAP_ACTION_SHAPES[0].newer;
|
||||
test.each([
|
||||
{
|
||||
kind: "a V4 step whose SETTLE by the user cannot be read",
|
||||
actions: [
|
||||
V4_SWAP_EXACT_IN_SINGLE_ID,
|
||||
V4_SETTLE_ID,
|
||||
V4_TAKE_ALL_ID,
|
||||
],
|
||||
params: [
|
||||
USDT_FOR_USDC_400,
|
||||
dirtyWord(settle(USDT_ADDR, USDT_400, true), 0),
|
||||
encodeV4TakeAll(USDC_ADDR, 0n),
|
||||
],
|
||||
},
|
||||
{
|
||||
kind: "a V4 step whose SETTLE_ALL cannot be read",
|
||||
actions: [
|
||||
V4_SWAP_EXACT_IN_SINGLE_ID,
|
||||
V4_SETTLE_ALL_ID,
|
||||
V4_TAKE_ALL_ID,
|
||||
],
|
||||
params: [
|
||||
USDT_FOR_USDC_400,
|
||||
dirtyWord(encodeV4SettleAll(USDT_ADDR, USDT_400), 0),
|
||||
encodeV4TakeAll(USDC_ADDR, 0n),
|
||||
],
|
||||
},
|
||||
{
|
||||
kind: "a V4 step whose swap action and SETTLE_ALL cannot be read",
|
||||
actions: [
|
||||
V4_SWAP_EXACT_IN_SINGLE_ID,
|
||||
V4_SETTLE_ALL_ID,
|
||||
V4_TAKE_ALL_ID,
|
||||
],
|
||||
params: [
|
||||
UNREAD_SWAP,
|
||||
dirtyWord(encodeV4SettleAll(WETH_ADDR, ONE_WETH), 0),
|
||||
encodeV4TakeAll(USDC_ADDR, 0n),
|
||||
],
|
||||
},
|
||||
])("a V3 step of 600 USDT, then $kind", ({ actions, params }) => {
|
||||
const result = decodeSteps(
|
||||
[0x00, 0x10],
|
||||
[V3_600, encodeV4Swap(new Uint8Array(actions), params)],
|
||||
);
|
||||
expect(linesBetweenTokens(result)).toEqual([
|
||||
["Moved from the sender", UNDECODED],
|
||||
]);
|
||||
});
|
||||
|
||||
test.each([
|
||||
{
|
||||
kind: "a V4 step swapping 400 USDT whose SETTLE by the user cannot be read",
|
||||
commands: [0x10],
|
||||
inputs: [
|
||||
encodeV4Swap(
|
||||
new Uint8Array([
|
||||
V4_SWAP_EXACT_IN_SINGLE_ID,
|
||||
V4_SETTLE_ID,
|
||||
V4_TAKE_ALL_ID,
|
||||
]),
|
||||
[
|
||||
USDT_FOR_USDC_400,
|
||||
dirtyWord(settle(USDT_ADDR, USDT_400, true), 0),
|
||||
encodeV4TakeAll(USDC_ADDR, 0n),
|
||||
],
|
||||
),
|
||||
],
|
||||
},
|
||||
{
|
||||
kind: "a V3 step of 600 USDT, then a V4 step whose input cannot be read",
|
||||
commands: [0x00, 0x10],
|
||||
inputs: [
|
||||
V3_600,
|
||||
dirtyWord(
|
||||
encodeV4Swap(new Uint8Array([V4_SETTLE_ID]), [
|
||||
settle(USDT_ADDR, USDT_400, true),
|
||||
]),
|
||||
2,
|
||||
),
|
||||
],
|
||||
},
|
||||
{
|
||||
kind: "a V4 step with no swap action whose SETTLE_ALL cannot be read, then a V3 step of 600 USDT",
|
||||
commands: [0x10, 0x00],
|
||||
inputs: [
|
||||
encodeV4Swap(
|
||||
new Uint8Array([V4_TAKE_ID, V4_SETTLE_ALL_ID]),
|
||||
[
|
||||
take(USDT_ADDR, OTHER_ADDR, USDT_400),
|
||||
dirtyWord(
|
||||
encodeV4SettleAll(USDT_ADDR, USDT_400),
|
||||
0,
|
||||
),
|
||||
],
|
||||
),
|
||||
V3_600,
|
||||
],
|
||||
},
|
||||
{
|
||||
kind: "a V3 step of 600 USDT, then a V2 step the user pays for whose input cannot be read",
|
||||
commands: [0x00, 0x08],
|
||||
inputs: [
|
||||
V3_600,
|
||||
dirtyWord(
|
||||
encodeV2SwapExactIn(OTHER_ADDR, USDT_400, 1n, [
|
||||
USDT_ADDR,
|
||||
USDC_ADDR,
|
||||
]),
|
||||
0,
|
||||
),
|
||||
],
|
||||
},
|
||||
{
|
||||
kind: "a V3 step of 600 USDT, then a PERMIT2_TRANSFER_FROM whose input cannot be read",
|
||||
commands: [0x00, 0x02],
|
||||
inputs: [
|
||||
V3_600,
|
||||
dirtyWord(
|
||||
coder.encode(
|
||||
["address", "address", "uint160"],
|
||||
[USDT_ADDR, OTHER_ADDR, USDT_400],
|
||||
),
|
||||
1,
|
||||
),
|
||||
],
|
||||
},
|
||||
{
|
||||
kind: "a V3 step of 600 USDT, then a PERMIT2_TRANSFER_FROM_BATCH",
|
||||
commands: [0x00, 0x0d],
|
||||
inputs: [
|
||||
V3_600,
|
||||
coder.encode(
|
||||
["tuple(address,address,uint160,address)[]"],
|
||||
[[[USER_ADDR, OTHER_ADDR, USDT_400, USDT_ADDR]]],
|
||||
),
|
||||
],
|
||||
},
|
||||
])("$kind", ({ commands, inputs }) => {
|
||||
const result = decodeSteps(commands, inputs);
|
||||
expect(linesBetweenTokens(result)).toEqual([
|
||||
["Moved from the sender", UNDECODED],
|
||||
]);
|
||||
});
|
||||
|
||||
// The steps of an EXECUTE_SUB_PLAN may take from the sender too, so
|
||||
// wherever it stands one line says so, and the figure of another
|
||||
// take cannot read as all that leaves.
|
||||
const SUB_PLAN = encodeSubPlan("0x00", [V3_600]);
|
||||
const V2_DAI_400 = encodeV2SwapExactIn(USER_ADDR, DAI_400, 390000000n, [
|
||||
DAI_ADDR,
|
||||
USDC_ADDR,
|
||||
]);
|
||||
test.each([
|
||||
{
|
||||
kind: "a V3 step of 600 USDT and a V2 step of 400 DAI, then an EXECUTE_SUB_PLAN",
|
||||
commands: [0x00, 0x08, 0x21],
|
||||
inputs: [V3_600, V2_DAI_400, SUB_PLAN],
|
||||
lines: [
|
||||
["Moved from the sender", "400.0000 DAI"],
|
||||
["Token moved", "DAI (" + DAI_ADDR + ")"],
|
||||
["Moved to", "The swap step that spends it"],
|
||||
["Moved from the sender", UNDECODED],
|
||||
],
|
||||
},
|
||||
{
|
||||
kind: "an EXECUTE_SUB_PLAN, then a V3 step of 600 USDT and a V2 step of 400 DAI",
|
||||
commands: [0x21, 0x00, 0x08],
|
||||
inputs: [SUB_PLAN, V3_600, V2_DAI_400],
|
||||
lines: [
|
||||
["Moved from the sender", UNDECODED],
|
||||
["Moved from the sender", "400.0000 DAI"],
|
||||
["Token moved", "DAI (" + DAI_ADDR + ")"],
|
||||
["Moved to", "The swap step that spends it"],
|
||||
],
|
||||
},
|
||||
{
|
||||
kind: "a V3 step of 600 USDT and a PERMIT2_TRANSFER_FROM of 400 DAI, then an EXECUTE_SUB_PLAN",
|
||||
commands: [0x00, 0x02, 0x21],
|
||||
inputs: [
|
||||
V3_600,
|
||||
coder.encode(
|
||||
["address", "address", "uint160"],
|
||||
[DAI_ADDR, OTHER_ADDR, DAI_400],
|
||||
),
|
||||
SUB_PLAN,
|
||||
],
|
||||
lines: [
|
||||
["Moved from the sender", UNDECODED],
|
||||
["Moved from the sender", "400.0000 DAI"],
|
||||
["Token moved", "DAI (" + DAI_ADDR + ")"],
|
||||
["Moved to", OTHER_ADDR],
|
||||
],
|
||||
},
|
||||
])("$kind", ({ commands, inputs, lines }) => {
|
||||
const result = decodeSteps(commands, inputs);
|
||||
expect(linesBetweenTokens(result)).toEqual(lines);
|
||||
});
|
||||
|
||||
// A PERMIT2_PERMIT in the plain shape of Uniswap's own routes keeps
|
||||
// its own amount: Permit2 lets the router take no more of the token,
|
||||
// so the steps after it do not add to it.
|
||||
test("a split after a PERMIT2_PERMIT shows the permit's amount", () => {
|
||||
const data = buildExecute(
|
||||
solidityPacked(["uint8", "uint8", "uint8"], [0x0a, 0x00, 0x08]),
|
||||
[
|
||||
encodePermit2(USDT_ADDR, 5000000000n, ROUTER_ADDR), // 5000 USDT
|
||||
encodeV3SwapExactIn(USER_ADDR, USDT_600, 590000000n, [
|
||||
USDT_ADDR,
|
||||
USDC_ADDR,
|
||||
]),
|
||||
encodeV2SwapExactIn(USER_ADDR, USDT_400, 390000000n, [
|
||||
USDT_ADDR,
|
||||
USDC_ADDR,
|
||||
]),
|
||||
],
|
||||
9999999999n,
|
||||
);
|
||||
|
||||
const result = uniswap.decode(
|
||||
data,
|
||||
ROUTER_ADDR,
|
||||
"0x1",
|
||||
{},
|
||||
USER_ADDR,
|
||||
);
|
||||
expect(result).not.toBeNull();
|
||||
|
||||
expect(detail(result, "Amount").value).toBe("5000.0000 USDT");
|
||||
expect(detail(result, "Moved from the sender")).toBeUndefined();
|
||||
});
|
||||
|
||||
// Out of that shape the permit caps nothing the Amount line can rely
|
||||
// on, so the line gives the total the steps take, as with no permit.
|
||||
const ONE_USDT_PERMIT = (spender) =>
|
||||
encodePermit2(USDT_ADDR, 1000000n, spender);
|
||||
test.each([
|
||||
{
|
||||
kind: "to another spender",
|
||||
commands: [0x0a],
|
||||
permits: [ONE_USDT_PERMIT(OTHER_ADDR)],
|
||||
},
|
||||
{
|
||||
kind: "that the router lets fail",
|
||||
commands: [0x8a],
|
||||
permits: [ONE_USDT_PERMIT(ROUTER_ADDR)],
|
||||
},
|
||||
{
|
||||
kind: "followed by a second one",
|
||||
commands: [0x0a, 0x0a],
|
||||
permits: [
|
||||
ONE_USDT_PERMIT(ROUTER_ADDR),
|
||||
ONE_USDT_PERMIT(ROUTER_ADDR),
|
||||
],
|
||||
},
|
||||
])(
|
||||
"a split after a PERMIT2_PERMIT $kind shows the total the steps take",
|
||||
({ commands, permits }) => {
|
||||
const result = decodeSteps(
|
||||
[...commands, 0x00, 0x08],
|
||||
[
|
||||
...permits,
|
||||
V3_600,
|
||||
encodeV2SwapExactIn(USER_ADDR, USDT_400, 390000000n, [
|
||||
USDT_ADDR,
|
||||
USDC_ADDR,
|
||||
]),
|
||||
],
|
||||
);
|
||||
expect(linesBetweenTokens(result)).toEqual([
|
||||
["Amount", "1000.0000 USDT"],
|
||||
]);
|
||||
},
|
||||
);
|
||||
|
||||
// A PERMIT2_PERMIT_BATCH, which this decoder does not read, may raise
|
||||
// what the router may take of the permit's token again.
|
||||
test("a split after a PERMIT2_PERMIT and a PERMIT2_PERMIT_BATCH shows the total the steps take", () => {
|
||||
const permitBatch = coder.encode(
|
||||
[
|
||||
"tuple(tuple(address,uint160,uint48,uint48)[],address,uint256)",
|
||||
"bytes",
|
||||
],
|
||||
[
|
||||
[
|
||||
[[USDT_ADDR, 10000000000n, 0, 0]], // 10,000 USDT
|
||||
ROUTER_ADDR,
|
||||
9999999999,
|
||||
],
|
||||
"0x1234",
|
||||
],
|
||||
);
|
||||
const result = decodeSteps(
|
||||
[0x0a, 0x03, 0x00, 0x08],
|
||||
[
|
||||
encodePermit2(USDT_ADDR, USDT_600, ROUTER_ADDR),
|
||||
permitBatch,
|
||||
V3_600,
|
||||
encodeV2SwapExactIn(USER_ADDR, 9400000000n, 1n, [
|
||||
USDT_ADDR,
|
||||
USDC_ADDR,
|
||||
]),
|
||||
],
|
||||
);
|
||||
expect(linesBetweenTokens(result)).toEqual([
|
||||
["Amount", "10000.0000 USDT"],
|
||||
]);
|
||||
});
|
||||
|
||||
// Any other step this decoder does not read may do the same, for
|
||||
// example through the hook of the pool a V4_INITIALIZE_POOL sets up.
|
||||
test.each([
|
||||
{
|
||||
kind: "a V4_INITIALIZE_POOL",
|
||||
command: 0x13,
|
||||
input: coder.encode(
|
||||
[POOL_KEY, "uint160"],
|
||||
[
|
||||
[USDC_ADDR, USDT_ADDR, 3000, 60, OTHER_ADDR],
|
||||
79228162514264337593543950336n,
|
||||
],
|
||||
),
|
||||
},
|
||||
{
|
||||
kind: "a SWEEP whose input cannot be read",
|
||||
command: 0x04,
|
||||
input: dirtyWord(
|
||||
coder.encode(
|
||||
["address", "address", "uint256"],
|
||||
[USDC_ADDR, USER_ADDR, 0n],
|
||||
),
|
||||
1,
|
||||
),
|
||||
},
|
||||
])(
|
||||
"a split after a PERMIT2_PERMIT, with $kind between its steps, shows the total the steps take",
|
||||
({ command, input }) => {
|
||||
const result = decodeSteps(
|
||||
[0x0a, 0x00, command, 0x08],
|
||||
[
|
||||
encodePermit2(USDT_ADDR, USDT_600, ROUTER_ADDR),
|
||||
V3_600,
|
||||
input,
|
||||
encodeV2SwapExactIn(USER_ADDR, 9400000000n, 1n, [
|
||||
USDT_ADDR,
|
||||
USDC_ADDR,
|
||||
]),
|
||||
],
|
||||
);
|
||||
expect(linesBetweenTokens(result)).toEqual([
|
||||
["Amount", "10000.0000 USDT"],
|
||||
]);
|
||||
},
|
||||
);
|
||||
|
||||
// A V3_SWAP_EXACT_OUT the user pays for, of at most `amountInMax`
|
||||
// USDT for USDC. Its input is (recipient, amountOut, amountInMax,
|
||||
// path, payerIsUser), laid out as encodeV3SwapExactIn() writes one;
|
||||
// an exact-out path lists the token bought first.
|
||||
const v3ExactOut = (amountInMax) =>
|
||||
encodeV3SwapExactIn(USER_ADDR, 390000000n, amountInMax, [
|
||||
USDC_ADDR,
|
||||
USDT_ADDR,
|
||||
]);
|
||||
// A split exact-out route: a V3_SWAP_EXACT_OUT of at most 6,000 USDT
|
||||
// and a V2_SWAP_EXACT_OUT of at most 4,000 USDT, both paid by the
|
||||
// user, then a SWEEP of USDC to the user.
|
||||
const EXACT_OUT_SPLIT = [
|
||||
v3ExactOut(6000000000n),
|
||||
encodeV2SwapExactOut(USER_ADDR, 390000000n, 4000000000n, [
|
||||
USDT_ADDR,
|
||||
USDC_ADDR,
|
||||
]),
|
||||
coder.encode(
|
||||
["address", "address", "uint256"],
|
||||
[USDC_ADDR, USER_ADDR, 0n],
|
||||
),
|
||||
];
|
||||
// This decoder does not read a V3_SWAP_EXACT_OUT, so what one takes
|
||||
// leaves no Amount figure wherever it stands, and a permit's amount
|
||||
// does not stand.
|
||||
test.each([
|
||||
{
|
||||
kind: "a V3 exact-in of 600 USDT, then a V3_SWAP_EXACT_OUT",
|
||||
commands: [0x00, 0x01],
|
||||
inputs: [V3_600, v3ExactOut(USDT_400)],
|
||||
},
|
||||
{
|
||||
kind: "a PERMIT2_PERMIT of 10,000 USDT, then a V3_SWAP_EXACT_OUT, a V2_SWAP_EXACT_OUT and a SWEEP",
|
||||
commands: [0x0a, 0x01, 0x09, 0x04],
|
||||
inputs: [
|
||||
encodePermit2(USDT_ADDR, 10000000000n, ROUTER_ADDR),
|
||||
...EXACT_OUT_SPLIT,
|
||||
],
|
||||
},
|
||||
{
|
||||
kind: "a V3_SWAP_EXACT_OUT, a V2_SWAP_EXACT_OUT and a SWEEP",
|
||||
commands: [0x01, 0x09, 0x04],
|
||||
inputs: EXACT_OUT_SPLIT,
|
||||
},
|
||||
{
|
||||
kind: "a V3_SWAP_EXACT_OUT of at most 9,400 USDT, then a PERMIT2_PERMIT of 600 USDT and a V3 exact-in of 600 USDT",
|
||||
commands: [0x01, 0x0a, 0x00],
|
||||
inputs: [
|
||||
v3ExactOut(9400000000n),
|
||||
encodePermit2(USDT_ADDR, USDT_600, ROUTER_ADDR),
|
||||
V3_600,
|
||||
],
|
||||
},
|
||||
])(
|
||||
"$kind, all paid by the user, shows no Amount figure",
|
||||
({ commands, inputs }) => {
|
||||
const result = decodeSteps(commands, inputs);
|
||||
expect(linesBetweenTokens(result)).toEqual([
|
||||
["Moved from the sender", UNDECODED],
|
||||
]);
|
||||
},
|
||||
);
|
||||
|
||||
// A later step's amount that cannot be added to the Amount line,
|
||||
// because the amount of the step that set the input side is not a
|
||||
// quantity, gets lines of its own. When that step stated no amount,
|
||||
// it gets lines of its own too, saying so, so the 400 USDT cannot
|
||||
// read as all that leaves.
|
||||
const V2_EXACT_OUT_400 = encodeV2SwapExactOut(
|
||||
USER_ADDR,
|
||||
390000000n,
|
||||
USDT_400,
|
||||
[USDT_ADDR, USDC_ADDR],
|
||||
);
|
||||
const UP_TO_400_USDT = [
|
||||
["Moved from the sender", "Up to 400.0000 USDT"],
|
||||
["Token moved", "USDT (" + USDT_ADDR + ")"],
|
||||
["Moved to", "The swap step that spends it"],
|
||||
];
|
||||
const UNKNOWN_USDT = [
|
||||
["Moved from the sender", UNDECODED],
|
||||
["Token moved", "USDT (" + USDT_ADDR + ")"],
|
||||
["Moved to", "The swap step that spends it"],
|
||||
];
|
||||
// A V4 exact-out step of at most 600 USDT for 1 WETH, in the shape
|
||||
// of Uniswap's own routes: a SETTLE of OPEN_DELTA by the user pays
|
||||
// what the swap spends.
|
||||
const V4_EXACT_OUT_600 = encodeV4Swap(
|
||||
new Uint8Array([
|
||||
V4_SWAP_EXACT_OUT_SINGLE_ID,
|
||||
V4_SETTLE_ID,
|
||||
V4_TAKE_ALL_ID,
|
||||
]),
|
||||
[
|
||||
encodeV4ExactOutSingle(
|
||||
USDT_ADDR,
|
||||
WETH_ADDR,
|
||||
ONE_WETH,
|
||||
USDT_600,
|
||||
),
|
||||
encodeV4Settle(USDT_ADDR),
|
||||
encodeV4TakeAll(WETH_ADDR, 0n),
|
||||
],
|
||||
);
|
||||
test.each([
|
||||
{
|
||||
kind: "a V4 exact-out step with a SETTLE of OPEN_DELTA by the user",
|
||||
commands: [0x10, 0x09],
|
||||
first: V4_EXACT_OUT_600,
|
||||
lines: [...UNKNOWN_USDT, ...UP_TO_400_USDT],
|
||||
},
|
||||
// Settled by the user, the step's amount would be what that
|
||||
// SETTLE pays, which the decoder cannot state here.
|
||||
{
|
||||
kind: "a V4 exact-in step of the open delta, settled from the router",
|
||||
commands: [0x10, 0x09],
|
||||
first: encodeV4Swap(
|
||||
new Uint8Array([
|
||||
V4_SWAP_EXACT_IN_SINGLE_ID,
|
||||
V4_SETTLE_ID,
|
||||
V4_TAKE_ALL_ID,
|
||||
]),
|
||||
[
|
||||
encodeV4ExactInSingle(USDT_ADDR, USDC_ADDR, 0n, 1n),
|
||||
settle(USDT_ADDR, 0n, false),
|
||||
encodeV4TakeAll(USDC_ADDR, 0n),
|
||||
],
|
||||
),
|
||||
lines: [
|
||||
["Amount", "All available (V4 open delta)"],
|
||||
...UP_TO_400_USDT,
|
||||
],
|
||||
},
|
||||
{
|
||||
kind: "a V2 exact-in step of ALREADY_PAID",
|
||||
commands: [0x08, 0x09],
|
||||
first: encodeV2SwapExactIn(USER_ADDR, 0n, 1n, [
|
||||
USDT_ADDR,
|
||||
USDC_ADDR,
|
||||
]),
|
||||
lines: [
|
||||
[
|
||||
"Amount",
|
||||
"Whatever an earlier step sent to the pair (V2 already paid)",
|
||||
],
|
||||
...UP_TO_400_USDT,
|
||||
],
|
||||
},
|
||||
])(
|
||||
"$kind, then a V2 exact-out of at most 400 USDT the user pays for, shows the 400 USDT",
|
||||
({ commands, first, lines }) => {
|
||||
const result = decodeSteps(commands, [first, V2_EXACT_OUT_400]);
|
||||
expect(linesBetweenTokens(result)).toEqual(lines);
|
||||
},
|
||||
);
|
||||
|
||||
// The V4 exact-out route above the other way round, where the later
|
||||
// take's unknown amount leaves no figure at all, and other ways the
|
||||
// step that sets the input side states no amount.
|
||||
test.each([
|
||||
{
|
||||
kind: "a V2 exact-out of at most 400 USDT, then a V4 exact-out step of at most 600 USDT",
|
||||
commands: [0x09, 0x10],
|
||||
inputs: [V2_EXACT_OUT_400, V4_EXACT_OUT_600],
|
||||
lines: UNKNOWN_USDT,
|
||||
},
|
||||
{
|
||||
kind: "a PERMIT2_PERMIT of 1 USDT to another spender, a V4 exact-out step of at most 600 USDT, then a V2 exact-out of at most 400 USDT",
|
||||
commands: [0x0a, 0x10, 0x09],
|
||||
inputs: [
|
||||
encodePermit2(USDT_ADDR, 1000000n, OTHER_ADDR),
|
||||
V4_EXACT_OUT_600,
|
||||
V2_EXACT_OUT_400,
|
||||
],
|
||||
lines: [...UNKNOWN_USDT, ...UP_TO_400_USDT],
|
||||
},
|
||||
{
|
||||
kind: "a V4 step whose swap action cannot be read, with a SETTLE of WETH by the user, then a V2 exact-out of at most 400 USDT",
|
||||
commands: [0x10, 0x09],
|
||||
inputs: [
|
||||
encodeV4Swap(
|
||||
new Uint8Array([
|
||||
V4_SWAP_EXACT_IN_SINGLE_ID,
|
||||
V4_SETTLE_ID,
|
||||
V4_TAKE_ALL_ID,
|
||||
]),
|
||||
[
|
||||
UNREAD_SWAP,
|
||||
encodeV4Settle(WETH_ADDR),
|
||||
encodeV4TakeAll(USDC_ADDR, 0n),
|
||||
],
|
||||
),
|
||||
V2_EXACT_OUT_400,
|
||||
],
|
||||
lines: [
|
||||
["Moved from the sender", UNDECODED],
|
||||
["Token moved", "WETH (" + WETH_ADDR + ")"],
|
||||
["Moved to", "The swap step that spends it"],
|
||||
...UP_TO_400_USDT,
|
||||
],
|
||||
},
|
||||
])(
|
||||
"$kind, all paid by the user, shows that an amount is not known",
|
||||
({ commands, inputs, lines }) => {
|
||||
const result = decodeSteps(commands, inputs);
|
||||
expect(linesBetweenTokens(result)).toEqual(lines);
|
||||
},
|
||||
);
|
||||
|
||||
// A V2 exact-out step makes every amount the swap steps spend a maximum,
|
||||
// the total included.
|
||||
test("a split with a V2 exact-out step the user pays for shows the total as a maximum", () => {
|
||||
const data = buildExecute(
|
||||
solidityPacked(["uint8", "uint8"], [0x00, 0x09]),
|
||||
[
|
||||
encodeV3SwapExactIn(USER_ADDR, USDT_600, 590000000n, [
|
||||
USDT_ADDR,
|
||||
USDC_ADDR,
|
||||
]),
|
||||
encodeV2SwapExactOut(USER_ADDR, 390000000n, USDT_400, [
|
||||
USDT_ADDR,
|
||||
USDC_ADDR,
|
||||
]),
|
||||
],
|
||||
9999999999n,
|
||||
);
|
||||
|
||||
const result = uniswap.decode(
|
||||
data,
|
||||
ROUTER_ADDR,
|
||||
"0x1",
|
||||
{},
|
||||
USER_ADDR,
|
||||
);
|
||||
expect(result).not.toBeNull();
|
||||
|
||||
expect(detail(result, "Amount").value).toBe("Up to 1000.0000 USDT");
|
||||
});
|
||||
});
|
||||
|
||||
// https://git.eeqj.de/sneak/AutistMask/issues/359 — the output half, in
|
||||
// the shape the issue measured: a V4 step that states a minimum of zero
|
||||
// and names no output currency.
|
||||
@@ -1403,7 +2358,9 @@ describe("uniswap decoder", () => {
|
||||
// (v4-periphery ActionConstants.OPEN_DELTA = 0, applied by V4Router's
|
||||
// _swapExactInputSingle / _swapExactInput). It is not a quantity, and
|
||||
// printing "0.0000 WETH" for it would state the exact inverse of what the
|
||||
// step does. Against c9ebac8 the Amount line was omitted entirely.
|
||||
// step does. Against c9ebac8 the Amount line was omitted entirely. The
|
||||
// SETTLE is paid from the router: one paid by the user would make the
|
||||
// step's amount what that SETTLE pays.
|
||||
test("a V4 open-delta amountIn is named, not printed as zero", () => {
|
||||
const data = buildExecute(
|
||||
"0x10",
|
||||
@@ -1415,7 +2372,10 @@ describe("uniswap decoder", () => {
|
||||
V4_TAKE_ID,
|
||||
]),
|
||||
[
|
||||
encodeV4Settle(WETH_ADDR),
|
||||
coder.encode(
|
||||
["address", "uint256", "bool"],
|
||||
[WETH_ADDR, 0n, false],
|
||||
),
|
||||
encodeV4ExactInSingle(
|
||||
WETH_ADDR,
|
||||
USDC_ADDR,
|
||||
|
||||
@@ -671,6 +671,7 @@ describe("any token left in the router is not received", () => {
|
||||
v3SwapExactIn(MSG_SENDER, USDT_2000, USDC_1990, USDT, USDC),
|
||||
),
|
||||
left: tokenLine(WETH, "WETH"),
|
||||
spent: "2000.0000 USDT",
|
||||
},
|
||||
{
|
||||
kind: "a WRAP_ETH of 1 ETH into the router, then a swap of 0.5 WETH from the router",
|
||||
@@ -697,6 +698,7 @@ describe("any token left in the router is not received", () => {
|
||||
v2Swap(0x08, MSG_SENDER, ONE_WETH, USDC_1990, [WETH, USDC]),
|
||||
),
|
||||
left: tokenLine(WETH, "WETH"),
|
||||
spent: "1.0000 WETH",
|
||||
},
|
||||
{
|
||||
kind: "a WRAP_ETH of 1 ETH into the router, then a V3 swap of 1 WETH that the user pays for",
|
||||
@@ -705,6 +707,7 @@ describe("any token left in the router is not received", () => {
|
||||
v3SwapExactIn(MSG_SENDER, ONE_WETH, USDC_1990, WETH, USDC),
|
||||
),
|
||||
left: tokenLine(WETH, "WETH"),
|
||||
spent: "1.0000 WETH",
|
||||
},
|
||||
{
|
||||
kind: "a WRAP_ETH of 1 ETH into the router, then a V4 swap of 1 WETH with a SETTLE of 1 WETH by the user",
|
||||
@@ -717,6 +720,7 @@ describe("any token left in the router is not received", () => {
|
||||
),
|
||||
),
|
||||
left: tokenLine(WETH, "WETH"),
|
||||
spent: "1.0000 WETH",
|
||||
},
|
||||
{
|
||||
kind: "a swap paying WETH to the router, a WRAP_ETH of 1 ETH into the router, then a swap of 1 WETH from the router",
|
||||
@@ -792,9 +796,13 @@ describe("any token left in the router is not received", () => {
|
||||
),
|
||||
),
|
||||
left: tokenLine(WETH, "WETH"),
|
||||
// The step has two SETTLEs of WETH, so what the user pays is not
|
||||
// known.
|
||||
spent: UNDECODED,
|
||||
},
|
||||
// The user pays for the swap by a SETTLE_ALL or SETTLE whose currency
|
||||
// the decoder cannot read, so the SETTLE from the router pays nothing.
|
||||
// the decoder cannot read, so the SETTLE from the router pays nothing,
|
||||
// and what the user pays is not known.
|
||||
{
|
||||
kind: "a WRAP_ETH of 1 ETH into the router, then a V4 swap of 1 WETH with a SETTLE_ALL that cannot be read and a SETTLE of OPEN_DELTA from the router",
|
||||
data: execute(
|
||||
@@ -807,6 +815,7 @@ describe("any token left in the router is not received", () => {
|
||||
),
|
||||
),
|
||||
left: tokenLine(WETH, "WETH"),
|
||||
unread: true,
|
||||
},
|
||||
{
|
||||
kind: "a WRAP_ETH of 1 ETH into the router, then a V4 swap of 1 WETH with a SETTLE by the user that cannot be read and a SETTLE of OPEN_DELTA from the router",
|
||||
@@ -820,6 +829,7 @@ describe("any token left in the router is not received", () => {
|
||||
),
|
||||
),
|
||||
left: tokenLine(WETH, "WETH"),
|
||||
unread: true,
|
||||
},
|
||||
{
|
||||
kind: "a WRAP_ETH of 1 ETH into the router, then a V4 step with an exact-in of 1 WETH less 1,000 wei and an empty path, a swap of 1,000 wei, and a SETTLE of OPEN_DELTA from the router",
|
||||
@@ -873,12 +883,20 @@ describe("any token left in the router is not received", () => {
|
||||
),
|
||||
left: { label: "Token moved into the router", value: "ETH" },
|
||||
},
|
||||
])("$kind", ({ data, left }) => {
|
||||
])("$kind", ({ data, left, spent, unread }) => {
|
||||
const result = decode(data);
|
||||
expect(labels(result)).toEqual([
|
||||
"Protocol",
|
||||
"Token In",
|
||||
"Amount",
|
||||
// A later step whose SETTLE or SETTLE_ALL the decoder cannot read
|
||||
// may take anything from the sender: one line says so, in place
|
||||
// of the Amount line (https://git.eeqj.de/sneak/AutistMask/issues/625).
|
||||
unread ? "Moved from the sender" : "Amount",
|
||||
// A later swap step the user pays for spends `spent` of a token
|
||||
// other than Token In.
|
||||
...(spent
|
||||
? ["Moved from the sender", "Token moved", "Moved to"]
|
||||
: []),
|
||||
"Token Out",
|
||||
"Paid to",
|
||||
"Token moved into the router",
|
||||
@@ -886,6 +904,14 @@ describe("any token left in the router is not received", () => {
|
||||
"Steps",
|
||||
"Deadline",
|
||||
]);
|
||||
if (spent) {
|
||||
expect(detail(result, "Moved from the sender").value).toBe(spent);
|
||||
}
|
||||
if (unread) {
|
||||
expect(detail(result, "Moved from the sender").value).toBe(
|
||||
UNDECODED,
|
||||
);
|
||||
}
|
||||
expect(paidTo(result)).toEqual([STAYS_IN_ROUTER]);
|
||||
expect(detail(result, "Token moved into the router")).toEqual(left);
|
||||
expect(detail(result, "Min. paid out").value).toBe("1990.0000 USDC");
|
||||
|
||||
Reference in New Issue
Block a user