@rabby-wallet/rabby-swap 0.0.88 → 0.0.89-alpha.0

package/dist/abi.d.ts

@@ -335,4 +335,6 @@ export declare const SushiABI: ({
     stateMutability: string;
     type: string;
 })[];
+export { UniABI } from "./calldata/uni/abi";
+export { MagpieABI } from "./calldata/magpie/abi";
 export declare const PancakeSwapABI: string[];

package/dist/abi.js

@@ -1652,6 +1652,8 @@ export const ZeroXABIV2 = [
     { stateMutability: "payable", type: "fallback" },
 ];
 export const SushiABI = [{ "inputs": [], "stateMutability": "nonpayable", "type": "constructor" }, { "inputs": [{ "internalType": "address", "name": "tokenOut", "type": "address" }, { "internalType": "uint256", "name": "amountOut", "type": "uint256" }], "name": "MinimalOutputBalanceViolation", "type": "error" }, { "inputs": [], "name": "safeExecutor", "outputs": [{ "internalType": "contract SafeExecutor", "name": "", "type": "address" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "contract IERC20", "name": "tokenIn", "type": "address" }, { "internalType": "uint256", "name": "amountIn", "type": "uint256" }, { "internalType": "address", "name": "recipient", "type": "address" }, { "internalType": "contract IERC20", "name": "tokenOut", "type": "address" }, { "internalType": "uint256", "name": "amountOutMin", "type": "uint256" }, { "internalType": "address", "name": "executor", "type": "address" }, { "internalType": "bytes", "name": "executorData", "type": "bytes" }], "name": "snwap", "outputs": [{ "internalType": "uint256", "name": "amountOut", "type": "uint256" }], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "components": [{ "internalType": "contract IERC20", "name": "token", "type": "address" }, { "internalType": "uint256", "name": "amountIn", "type": "uint256" }, { "internalType": "address", "name": "transferTo", "type": "address" }], "internalType": "struct InputToken[]", "name": "inputTokens", "type": "tuple[]" }, { "components": [{ "internalType": "contract IERC20", "name": "token", "type": "address" }, { "internalType": "address", "name": "recipient", "type": "address" }, { "internalType": "uint256", "name": "amountOutMin", "type": "uint256" }], "internalType": "struct OutputToken[]", "name": "outputTokens", "type": "tuple[]" }, { "components": [{ "internalType": "address", "name": "executor", "type": "address" }, { "internalType": "uint256", "name": "value", "type": "uint256" }, { "internalType": "bytes", "name": "data", "type": "bytes" }], "internalType": "struct Executor[]", "name": "executors", "type": "tuple[]" }], "name": "snwapMultiple", "outputs": [{ "internalType": "uint256[]", "name": "amountOut", "type": "uint256[]" }], "stateMutability": "payable", "type": "function" }];
+export { UniABI } from "./calldata/uni/abi";
+export { MagpieABI } from "./calldata/magpie/abi";
 // IAggregator.swapExactIn from the official router's verified implementation:
 // https://sourcify.dev/server/v2/contract/56/0x88b20da52208607e3bf06a59605acebbe7d2e3d6?fields=abi,sources
 export const PancakeSwapABI = [

package/dist/calldata/chain.d.ts

@@ -0,0 +1 @@
+export declare const getNativeTokenAddress: (chainId: number, nativeTokenAddress?: string) => string;

package/dist/calldata/chain.js

@@ -0,0 +1,9 @@
+import { CHAINS } from "@debank/common";
+export const getNativeTokenAddress = (chainId, nativeTokenAddress) => {
+    var _a;
+    const native = nativeTokenAddress !== null && nativeTokenAddress !== void 0 ? nativeTokenAddress : (_a = Object.values(CHAINS).find((chain) => chain.id === chainId)) === null || _a === void 0 ? void 0 : _a.nativeTokenAddress;
+    if (!native) {
+        throw new Error(`Native token is not configured for chain ${chainId}`);
+    }
+    return native;
+};

package/dist/calldata/magpie/abi.d.ts

@@ -0,0 +1 @@
+export declare const MagpieABI: string[];

package/dist/calldata/magpie/abi.js

@@ -0,0 +1,3 @@
+export const MagpieABI = [
+    "function swapWithBackendSignature(bytes swapData) payable returns (uint256 amountOut)",
+];

package/dist/calldata/magpie/dexAggregator.d.ts

@@ -0,0 +1,3 @@
+import { PackedReader, PackedSwap } from "./packed";
+export declare const decodeDexAggregator: (data: PackedReader) => PackedSwap;
+export declare const decodeDexAggregatorInputFee: (data: PackedReader) => string;

package/dist/calldata/magpie/dexAggregator.js

@@ -0,0 +1,32 @@
+import BigNumber from "bignumber.js";
+// DexAggregator LibRouter.getData(), verified Arbitrum source:
+// https://sourcify.dev/server/v2/contract/42161/0x20F6ee51340aDEed01A59B0e65cB3703f3dc860c?fields=sources
+export const decodeDexAggregator = (data) => ({
+    receiver: data.address(72),
+    fromAsset: data.address(92),
+    toAsset: data.address(112),
+    amountIn: data.uint(132),
+    amountOutMin: data.compact(167, 168),
+});
+// LibRouter.getData(): byte 274 holds the fee count, followed by three
+// arrays of compact descriptors (asset, receiver, amount), 3 bytes per entry.
+// transferFees() transfers these separately from the swap's amountIn.
+// Only input-asset fees fit the single-asset payment checked against the quote.
+// https://sourcify.dev/server/v2/contract/42161/0x20F6ee51340aDEed01A59B0e65cB3703f3dc860c?fields=sources
+// https://docs.fly.trade/developers/api-reference/evm-swap-integration-guide#step-1-get-a-quote
+export const decodeDexAggregatorInputFee = (data) => {
+    const count = Number(data.uint(274, 1));
+    const inputAsset = new BigNumber(data.address(92).slice(2), 16);
+    let total = new BigNumber(0);
+    for (let index = 0; index < count; index++) {
+        const assetOffset = 275 + index * 3;
+        const amountOffset = 275 + (count * 2 + index) * 3;
+        const asset = data.compact(assetOffset, assetOffset + 1);
+        const amount = data.compact(amountOffset, amountOffset + 1);
+        if (inputAsset.eq(asset))
+            total = total.plus(amount);
+        else if (new BigNumber(amount).gt(0))
+            throw new Error("Non-input-asset Magpie fees are not supported");
+    }
+    return total.toFixed(0);
+};

package/dist/calldata/magpie/index.d.ts

@@ -0,0 +1,3 @@
+import type { DecodeCalldataOptions, DecodeCalldataResult, TxWithChainId } from "../types";
+export declare const decodeInputFee: (tx: TxWithChainId, decoded?: DecodeCalldataResult) => string;
+export declare const decodeCalldata: (tx: TxWithChainId, options?: DecodeCalldataOptions) => DecodeCalldataResult;

package/dist/calldata/magpie/index.js

@@ -0,0 +1,65 @@
+import { Interface } from "@ethersproject/abi";
+import BigNumber from "bignumber.js";
+import { getNativeTokenAddress } from "../chain";
+import { isSameAddress, NULL_ADDRESS } from "../../utils";
+import { MagpieABI } from "./abi";
+import { decodeDexAggregator, decodeDexAggregatorInputFee, } from "./dexAggregator";
+import { PackedReader } from "./packed";
+const magpieInterface = new Interface(MagpieABI);
+const dexAggregatorSelector = magpieInterface.getSighash("swapWithBackendSignature");
+// Keep parsing details private and tied to the decoded result's lifetime.
+const decodedPayloads = new WeakMap();
+const readPayload = (tx) => {
+    const selector = tx.data.slice(0, 10).toLowerCase();
+    if (selector !== dexAggregatorSelector) {
+        throw new Error(`Unsupported Magpie calldata selector: ${selector}`);
+    }
+    const transaction = magpieInterface.parseTransaction({ data: tx.data });
+    const payloadLength = (transaction.args[0].length - 2) / 2;
+    return new PackedReader(tx.data, payloadLength);
+};
+export const decodeInputFee = (tx, decoded) => {
+    var _a;
+    const cached = decoded && decodedPayloads.get(decoded);
+    if (cached && cached.data === tx.data) {
+        return ((_a = cached.inputFee) !== null && _a !== void 0 ? _a : (cached.inputFee = decodeDexAggregatorInputFee(cached.payload)));
+    }
+    return decodeDexAggregatorInputFee(readPayload(tx));
+};
+export const decodeCalldata = (tx, options = {}) => {
+    const native = getNativeTokenAddress(tx.chainId, options.nativeTokenAddress);
+    const payload = readPayload(tx);
+    const swap = decodeDexAggregator(payload);
+    const nativeInput = isSameAddress(swap.fromAsset, NULL_ADDRESS);
+    let amountIn = new BigNumber(swap.amountIn);
+    // DexAggregator.adjustAmountIn(): zero means automatic input, not a zero
+    // debit. Native input is known from value minus encoded native fees;
+    // ERC20 input depends on min(balance, allowance), unavailable offline.
+    // https://sourcify.dev/server/v2/contract/42161/0x20F6ee51340aDEed01A59B0e65cB3703f3dc860c?fields=sources
+    const inputFee = nativeInput ? decodeDexAggregatorInputFee(payload) : "0";
+    if (amountIn.isZero()) {
+        if (!nativeInput)
+            throw new Error("Automatic ERC20 input depends on onchain balance and allowance; it cannot be determined from calldata alone");
+        amountIn = new BigNumber(tx.value).minus(inputFee);
+    }
+    if (!amountIn.gt(0))
+        throw new Error("Original input amount is zero or unresolved");
+    if (nativeInput && !amountIn.plus(inputFee).eq(tx.value))
+        throw new Error("Native transaction value does not equal input amount plus encoded native fees");
+    const decoded = {
+        fromToken: isSameAddress(swap.fromAsset, NULL_ADDRESS)
+            ? native
+            : swap.fromAsset,
+        fromTokenAmount: amountIn.toFixed(0),
+        toToken: isSameAddress(swap.toAsset, NULL_ADDRESS) ? native : swap.toAsset,
+        minReceiveToTokenAmount: swap.amountOutMin,
+        // LibRouter reads toAddress literally; zero is not a msg.sender sentinel.
+        toTokenReceiver: swap.receiver,
+    };
+    decodedPayloads.set(decoded, {
+        data: tx.data,
+        payload,
+        inputFee: nativeInput ? inputFee : undefined,
+    });
+    return decoded;
+};

package/dist/calldata/magpie/packed.d.ts

@@ -0,0 +1,16 @@
+export interface PackedSwap {
+    receiver: string;
+    fromAsset: string;
+    toAsset: string;
+    amountIn: string;
+    amountOutMin: string;
+}
+export declare class PackedReader {
+    private readonly payloadLength;
+    private readonly hex;
+    constructor(data: string, payloadLength: number);
+    private read;
+    address(offset: number): string;
+    uint(offset: number, length?: number): string;
+    compact(shiftOffset: number, pointerOffset: number): string;
+}

package/dist/calldata/magpie/packed.js

@@ -0,0 +1,30 @@
+import BigNumber from "bignumber.js";
+// Offsets include the selector. Reads must stay inside the declared bytes payload.
+export class PackedReader {
+    constructor(data, payloadLength) {
+        this.payloadLength = payloadLength;
+        this.hex = data.slice(2);
+    }
+    read(offset, length) {
+        if (offset < 68 || offset + length > 68 + this.payloadLength) {
+            throw new Error(`Packed field points outside the Magpie bytes payload (offset ${offset}, length ${length})`);
+        }
+        return this.hex.slice(offset * 2, (offset + length) * 2);
+    }
+    address(offset) {
+        return `0x${this.read(offset, 20)}`.toLowerCase();
+    }
+    uint(offset, length = 32) {
+        return new BigNumber(this.read(offset, length), 16).toFixed(0);
+    }
+    compact(shiftOffset, pointerOffset) {
+        const shift = Number(this.uint(shiftOffset, 1));
+        const pointer = Number(this.uint(pointerOffset, 2));
+        // Only the high (256 - shift) bits survive Solidity's shr.
+        const significantBits = 256 - shift;
+        const length = Math.ceil(significantBits / 8);
+        return new BigNumber(this.uint(pointer, length))
+            .idiv(new BigNumber(2).pow(length * 8 - significantBits))
+            .toFixed(0);
+    }
+}

package/dist/calldata/types.d.ts

@@ -0,0 +1,22 @@
+export interface Tx {
+    from: string;
+    to: string;
+    data: string;
+    value: string;
+    chainId?: number;
+    gas?: number;
+    gasPrice?: string;
+}
+export interface TxWithChainId extends Tx {
+    chainId: number;
+}
+export interface DecodeCalldataOptions {
+    nativeTokenAddress?: string;
+}
+export interface DecodeCalldataResult {
+    fromToken: string;
+    fromTokenAmount: string;
+    toToken: string;
+    minReceiveToTokenAmount: string;
+    toTokenReceiver: string;
+}

package/dist/calldata/types.js

@@ -0,0 +1 @@
+export {};

package/dist/calldata/uni/abi.d.ts

@@ -0,0 +1,3 @@
+export declare const UniversalRouterABI: import("ethers/lib/utils").FunctionFragment[];
+export declare const SwapProxyABI: import("ethers/lib/utils").FunctionFragment[];
+export declare const UniABI: import("ethers/lib/utils").FunctionFragment[];

package/dist/calldata/uni/abi.js

@@ -0,0 +1,6 @@
+import { SwapRouter } from "@uniswap/universal-router-sdk";
+// The current quote flow uses execute directly or through SwapProxy.
+// Keep the official ABI as the source of truth, excluding signed execution.
+export const UniversalRouterABI = Object.values(SwapRouter.INTERFACE.functions).filter((fragment) => fragment.name === "execute");
+export const SwapProxyABI = Object.values(SwapRouter.PROXY_INTERFACE.functions);
+export const UniABI = [...UniversalRouterABI, ...SwapProxyABI];

package/dist/calldata/uni/assets.d.ts

@@ -0,0 +1,5 @@
+import type { DecodeCalldataResult } from "../types";
+export declare const getArcNativeInputAmount: (token: string, chainId: number, txValue: string) => string | undefined;
+export declare const isSameUniAsset: (a: string, b: string, chainId: number, native: string) => boolean;
+export declare const normalizeUniAssets: (result: DecodeCalldataResult, chainId: number, native: string) => DecodeCalldataResult;
+export declare const getComparableUniInputAmount: (requestedAmount: string, decoded: DecodeCalldataResult, chainId: number, native: string) => string;

package/dist/calldata/uni/assets.js

@@ -0,0 +1,65 @@
+import BigNumber from "bignumber.js";
+import { isSameAddress } from "../../utils";
+import { ARC_ERC20_USDC } from "../../consts";
+const ARC_CHAIN_ID = 5042;
+const ARC_NATIVE_SCALE = "1000000000000";
+// Arc funds its ERC20 USDC route through msg.value without a WETH-style wrap.
+// Fix the complete input before reading individual router-funded split legs,
+// just as SwapProxy ingress / WRAP_ETH does on other routes. Keep ERC20 units
+// until normalizeUniAssets converts the final result to native units.
+// https://docs.arc.io/arc/concepts/stablecoin-native-model#two-interfaces-one-balance
+export const getArcNativeInputAmount = (token, chainId, txValue) => chainId === ARC_CHAIN_ID &&
+    isSameAddress(token, ARC_ERC20_USDC) &&
+    new BigNumber(txValue).gt(0)
+    ? new BigNumber(txValue).idiv(ARC_NATIVE_SCALE).toFixed(0)
+    : undefined;
+// Compare asset identity for refunds only. Do not merge raw native (18) and
+// ERC20 (6) amounts or balances: they share an asset, but use different units.
+// https://docs.arc.io/arc/concepts/stablecoin-native-model#two-interfaces-one-balance
+export const isSameUniAsset = (a, b, chainId, native) => {
+    const identity = (token) => chainId === ARC_CHAIN_ID && isSameAddress(token, ARC_ERC20_USDC)
+        ? native
+        : token;
+    return isSameAddress(identity(a), identity(b));
+};
+// Arc exposes one USDC balance as native (18 decimals) and ERC20 (6 decimals).
+// Normalize both the asset and its amount together, after route aggregation.
+// https://docs.arc.io/arc/concepts/stablecoin-native-model#two-interfaces-one-balance
+// Tempo pathUSD is a real 6-decimal TIP20; it must retain its contract address.
+export const normalizeUniAssets = (result, chainId, native) => {
+    if (chainId !== ARC_CHAIN_ID || isSameAddress(native, ARC_ERC20_USDC))
+        return result;
+    const nativeIn = isSameAddress(result.fromToken, ARC_ERC20_USDC);
+    const nativeOut = isSameAddress(result.toToken, ARC_ERC20_USDC);
+    return Object.assign(Object.assign(Object.assign({}, result), (nativeIn
+        ? {
+            fromToken: native,
+            fromTokenAmount: new BigNumber(result.fromTokenAmount)
+                .times(ARC_NATIVE_SCALE)
+                .toFixed(),
+        }
+        : {})), (nativeOut
+        ? {
+            toToken: native,
+            minReceiveToTokenAmount: new BigNumber(result.minReceiveToTokenAmount)
+                .times(ARC_NATIVE_SCALE)
+                .toFixed(),
+        }
+        : {}));
+};
+export const getComparableUniInputAmount = (requestedAmount, decoded, chainId, native) => {
+    // Keep exact native-value inputs intact. Only Arc's native USDC can also
+    // travel through its 6-decimal ERC20 interface, which truncates 12 digits.
+    // Compare against that exact integer conversion, without a general tolerance.
+    // https://www.arc.io/blog/arc-compatibility-guide-for-existing-evm-apps
+    if (decoded.fromTokenAmount !== requestedAmount &&
+        chainId === ARC_CHAIN_ID &&
+        isSameAddress(decoded.fromToken, native) &&
+        !isSameAddress(native, ARC_ERC20_USDC)) {
+        return new BigNumber(requestedAmount)
+            .idiv(ARC_NATIVE_SCALE)
+            .times(ARC_NATIVE_SCALE)
+            .toFixed(0);
+    }
+    return requestedAmount;
+};

package/dist/calldata/uni/index.d.ts

@@ -0,0 +1,2 @@
+import type { DecodeCalldataOptions, DecodeCalldataResult, TxWithChainId } from "../types";
+export declare const decodeCalldata: (tx: TxWithChainId, options?: DecodeCalldataOptions) => DecodeCalldataResult;

package/dist/calldata/uni/index.js

@@ -0,0 +1,40 @@
+import { Interface } from "@ethersproject/abi";
+import BigNumber from "bignumber.js";
+import { getNativeTokenAddress } from "../chain";
+import { UniABI } from "./abi";
+import { chainToken, finishSwap } from "./shared";
+import { walkCommands } from "./universalRouter/commands";
+import { getRouterProfile } from "./universalRouter/profiles";
+import { normalizeUniAssets } from "./assets";
+const uniInterface = new Interface(UniABI);
+export const decodeCalldata = (tx, options = {}) => {
+    var _a;
+    const native = getNativeTokenAddress(tx.chainId, options.nativeTokenAddress);
+    const transaction = uniInterface.parseTransaction({ data: tx.data });
+    const ctx = {
+        chainId: tx.chainId,
+        native,
+        sender: tx.from,
+        // SwapProxy calls execute normally, so the Router's msgSender() is the
+        // proxy, while tx.from remains the user whose requested payout we verify.
+        // https://github.com/Uniswap/universal-router/blob/main/contracts/SwapProxy.sol
+        routerCaller: transaction.args.router ? tx.to : tx.from,
+        // SwapProxy passes the actual Universal Router as an explicit argument.
+        router: transaction.args.router || tx.to,
+        proxyToken: transaction.args.token,
+        proxyAmount: (_a = transaction.args.amount) === null || _a === void 0 ? void 0 : _a.toString(),
+        txValue: tx.value,
+    };
+    const profile = getRouterProfile(ctx.chainId, ctx.router);
+    const swap = {};
+    if (new BigNumber(ctx.txValue).gt(0))
+        swap.pendingMinimums = { [ctx.native.toLowerCase()]: ctx.txValue };
+    if (ctx.proxyToken && ctx.proxyAmount && ctx.proxyAmount !== "0") {
+        swap.fromToken = ctx.proxyToken;
+        swap.fromTokenAmount = ctx.proxyAmount;
+        swap.inputAmountLocked = true;
+        (swap.pendingMinimums || (swap.pendingMinimums = {}))[chainToken(ctx.proxyToken, ctx.native).toLowerCase()] = ctx.proxyAmount;
+    }
+    walkCommands(transaction.args.commands, transaction.args.inputs, swap, ctx, profile);
+    return normalizeUniAssets(finishSwap(swap), tx.chainId, native);
+};

package/dist/calldata/uni/shared.d.ts

@@ -0,0 +1,45 @@
+import BigNumber from "bignumber.js";
+import type { DecodeCalldataResult } from "../types";
+export declare const MSG_SENDER = "0x0000000000000000000000000000000000000001";
+export declare const ROUTER = "0x0000000000000000000000000000000000000002";
+export declare const CONTRACT_BALANCE: BigNumber;
+export type Minimums = Record<string, string>;
+export interface Swap {
+    fromToken?: string;
+    fromTokenAmount?: string;
+    toToken?: string;
+    minReceive?: string;
+    receiver?: string;
+    inputAmountLocked?: boolean;
+    hasSwap?: boolean;
+    pendingMinimums?: Minimums;
+    payouts?: Record<string, {
+        token: string;
+        minimum: string;
+        receiver: string;
+    }>;
+}
+export interface Context {
+    chainId: number;
+    native: string;
+    sender: string;
+    routerCaller: string;
+    router: string;
+    txValue: string;
+    proxyToken?: string;
+    proxyAmount?: string;
+}
+export declare const chainToken: (token: string, native: string) => string;
+export declare const realAmount: (amount: string, fallback?: string) => string;
+export declare const assertInputAsset: (swap: Swap, ctx: Context, token: string) => void;
+export declare const setSwap: (swap: Swap, ctx: Context, fromToken: string, toToken: string, amountA: string, amountB: string, payment?: {
+    recipient?: string;
+    payerIsUser?: boolean;
+    inputPair?: string;
+    minimums?: Minimums;
+}) => void;
+export declare const setOutput: (swap: Swap, ctx: Context, token: string, recipient: string, minimum?: string, exactAmount?: boolean, poolMinimums?: Minimums) => void;
+export declare const payPortion: (swap: Swap, ctx: Context, token: string, recipient: string, portion: string, denominator: string, poolMinimums?: Minimums) => void;
+export declare const wrapNative: (swap: Swap, ctx: Context, amount: string, recipient: string) => void;
+export declare const unwrapNative: (swap: Swap, ctx: Context, recipient: string, minimum: string) => void;
+export declare const finishSwap: (swap: Swap) => DecodeCalldataResult;

package/dist/calldata/uni/shared.js

@@ -0,0 +1,223 @@
+import BigNumber from "bignumber.js";
+import { isSameAddress, NULL_ADDRESS } from "../../utils";
+import { getArcNativeInputAmount, isSameUniAsset } from "./assets";
+export const MSG_SENDER = "0x0000000000000000000000000000000000000001";
+export const ROUTER = "0x0000000000000000000000000000000000000002";
+const EETH = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+export const CONTRACT_BALANCE = new BigNumber(2).pow(255);
+export const chainToken = (token, native) => isSameAddress(token, NULL_ADDRESS) || isSameAddress(token, EETH)
+    ? native
+    : token;
+export const realAmount = (amount, fallback) => CONTRACT_BALANCE.eq(amount) && fallback ? fallback : amount;
+// Dispatcher.map() and BaseActionsRouter._mapRecipient() use the Router's
+// execution caller, which is SwapProxy for proxied swaps, not the outer user.
+// https://github.com/Uniswap/universal-router/blob/main/contracts/base/Dispatcher.sol
+// https://github.com/Uniswap/v4-periphery/blob/main/src/base/BaseActionsRouter.sol
+const resolveRecipient = (recipient, ctx) => isSameAddress(recipient, MSG_SENDER)
+    ? ctx.routerCaller
+    : isSameAddress(recipient, ROUTER)
+        ? ctx.router
+        : recipient;
+const isRouter = (recipient, ctx) => isSameAddress(resolveRecipient(recipient, ctx), ctx.router);
+const isInputRefund = (swap, ctx, output) => swap.hasSwap &&
+    isSameUniAsset(output, swap.fromToken || "", ctx.chainId, ctx.native) &&
+    !isSameUniAsset(output, swap.toToken || "", ctx.chainId, ctx.native);
+const recordPayout = (swap, ctx, token, recipient, minimum) => {
+    var _a;
+    const receiver = resolveRecipient(recipient, ctx);
+    const key = `${token.toLowerCase()}:${receiver.toLowerCase()}`;
+    const payouts = (swap.payouts || (swap.payouts = {}));
+    payouts[key] = {
+        token,
+        receiver,
+        minimum: new BigNumber(((_a = payouts[key]) === null || _a === void 0 ? void 0 : _a.minimum) || 0).plus(minimum).toFixed(),
+    };
+    swap.toToken = token;
+    swap.minReceive = payouts[key].minimum;
+    swap.receiver = receiver;
+};
+export const assertInputAsset = (swap, ctx, token) => {
+    if (swap.inputAmountLocked)
+        throw new Error("Additional user-funded debit after prepaid input cannot be represented by the locked input amount");
+    if (swap.fromToken &&
+        !isSameUniAsset(chainToken(token, ctx.native), swap.fromToken, ctx.chainId, ctx.native)) {
+        throw new Error("Multiple user-funded input assets cannot be represented as a single swap result");
+    }
+};
+export const setSwap = (swap, ctx, fromToken, toToken, amountA, amountB, payment = {}) => {
+    var _a;
+    const input = chainToken(fromToken, ctx.native);
+    const output = chainToken(toToken, ctx.native);
+    const pending = payment.minimums || (swap.pendingMinimums || (swap.pendingMinimums = {}));
+    const inputKey = input.toLowerCase();
+    const poolCredit = payment.minimums && pending[inputKey] !== undefined;
+    if (payment.payerIsUser === true)
+        assertInputAsset(swap, ctx, input);
+    if (payment.inputPair && payment.payerIsUser === false) {
+        // V3 / V4 can pay this token directly into the next V2 pair. Remove only
+        // that proven handoff, retaining payments to every other token or recipient.
+        const key = `${inputKey}:${payment.inputPair.toLowerCase()}`;
+        (_a = swap.payouts) === null || _a === void 0 ? true : delete _a[key];
+    }
+    if (!swap.inputAmountLocked) {
+        if (!swap.hasSwap) {
+            const nativeInputAmount = payment.payerIsUser === true
+                ? undefined
+                : isSameAddress(input, ctx.native) && new BigNumber(ctx.txValue).gt(0)
+                    ? ctx.txValue
+                    : getArcNativeInputAmount(input, ctx.chainId, ctx.txValue);
+            const amount = nativeInputAmount !== null && nativeInputAmount !== void 0 ? nativeInputAmount : realAmount(amountA, swap.fromTokenAmount || ctx.proxyAmount || ctx.txValue);
+            if (!new BigNumber(amount).gt(0) || CONTRACT_BALANCE.eq(amount)) {
+                throw new Error("Cannot determine the original input amount from a dynamic router balance");
+            }
+            swap.fromToken = input;
+            swap.fromTokenAmount = amount;
+            if (nativeInputAmount !== undefined)
+                swap.inputAmountLocked = true;
+        }
+        else if (payment.payerIsUser !== false &&
+            !poolCredit &&
+            isSameAddress(input, swap.fromToken || "")) {
+            const amount = amountA;
+            // Only explicit root inputs can be summed. Intermediate OPEN_DELTA (0)
+            // and CONTRACT_BALANCE values describe router funds, not another user debit.
+            if (!CONTRACT_BALANCE.eq(amount)) {
+                swap.fromTokenAmount = new BigNumber(swap.fromTokenAmount)
+                    .plus(amount)
+                    .toFixed();
+            }
+        }
+    }
+    if (payment.payerIsUser !== true && pending[inputKey] !== undefined) {
+        const amount = amountA;
+        pending[inputKey] =
+            amount === "0" || CONTRACT_BALANCE.eq(amount)
+                ? "0"
+                : BigNumber.max(0, new BigNumber(pending[inputKey]).minus(amount)).toFixed();
+    }
+    swap.toToken = output;
+    const minimum = amountB;
+    swap.hasSwap = true;
+    const recipient = payment.recipient || ROUTER;
+    if (isRouter(recipient, ctx)) {
+        const key = output.toLowerCase();
+        pending[key] = new BigNumber(pending[key] || 0).plus(minimum).toFixed();
+        swap.minReceive = pending[key];
+    }
+    else {
+        recordPayout(swap, ctx, output, recipient, minimum);
+    }
+};
+export const setOutput = (swap, ctx, token, recipient, minimum, exactAmount = false, poolMinimums) => {
+    var _a;
+    const output = chainToken(token, ctx.native);
+    if (isRouter(recipient, ctx) && !poolMinimums)
+        return;
+    const pending = poolMinimums || (swap.pendingMinimums || (swap.pendingMinimums = {}));
+    const key = output.toLowerCase();
+    const amount = (_a = minimum !== null && minimum !== void 0 ? minimum : pending[key]) !== null && _a !== void 0 ? _a : "0";
+    pending[key] = exactAmount
+        ? BigNumber.max(0, new BigNumber(pending[key] || 0).minus(amount)).toFixed()
+        : "0";
+    if (isRouter(recipient, ctx)) {
+        // TAKE moves pool credit into the router; it is not another pool credit
+        // or a payout to the user. Keep the two balances separate.
+        const routerMinimums = (swap.pendingMinimums || (swap.pendingMinimums = {}));
+        routerMinimums[key] = new BigNumber(routerMinimums[key] || 0)
+            .plus(amount)
+            .toFixed();
+        return;
+    }
+    // Only input returned to the user is a refund; third-party transfers must
+    // remain visible to the final payout checks.
+    if (isInputRefund(swap, ctx, output) &&
+        isSameAddress(resolveRecipient(recipient, ctx), ctx.sender))
+        return;
+    recordPayout(swap, ctx, output, recipient, amount);
+};
+// Payments.sol and V4Router TAKE_PORTION transfer floor(balance * portion /
+// denominator). Subtract that fee before a later balance-based payout.
+// https://github.com/Uniswap/universal-router/blob/main/contracts/modules/Payments.sol
+// https://github.com/Uniswap/v4-periphery/blob/main/src/V4Router.sol
+export const payPortion = (swap, ctx, token, recipient, portion, denominator, poolMinimums) => {
+    const ratio = new BigNumber(portion);
+    if (!ratio.isInteger() || ratio.lt(0) || ratio.gt(denominator))
+        throw new Error("Invalid payment portion");
+    if (isRouter(recipient, ctx) && !poolMinimums)
+        return;
+    const pending = poolMinimums || (swap.pendingMinimums || (swap.pendingMinimums = {}));
+    const output = chainToken(token, ctx.native);
+    const key = output.toLowerCase();
+    const minimum = new BigNumber(pending[key] || 0);
+    // The remaining balance and the fee are monotone functions of the balance;
+    // their lower bounds can both be computed from its known minimum.
+    const fee = minimum.times(ratio).idiv(denominator).toFixed(0);
+    pending[key] = minimum.minus(fee).toFixed(0);
+    if (poolMinimums && isRouter(recipient, ctx)) {
+        const routerMinimums = (swap.pendingMinimums || (swap.pendingMinimums = {}));
+        routerMinimums[key] = new BigNumber(routerMinimums[key] || 0)
+            .plus(fee)
+            .toFixed();
+    }
+    else if (isSameAddress(resolveRecipient(recipient, ctx), ctx.sender)) {
+        if (!isInputRefund(swap, ctx, output))
+            recordPayout(swap, ctx, output, recipient, fee);
+    }
+};
+export const wrapNative = (swap, ctx, amount, recipient) => {
+    if (!isRouter(recipient, ctx))
+        throw new Error("WRAP_ETH to an external recipient is not modeled as a single swap input");
+    const pending = (swap.pendingMinimums || (swap.pendingMinimums = {}));
+    const key = ctx.native.toLowerCase();
+    pending[key] = CONTRACT_BALANCE.eq(amount)
+        ? "0"
+        : BigNumber.max(0, new BigNumber(pending[key] || 0).minus(amount)).toFixed();
+    if (swap.hasSwap || swap.inputAmountLocked)
+        return;
+    swap.fromToken = ctx.native;
+    // msg.value is the complete native budget, including subsequent split wraps
+    // and any input eventually refunded, rather than just the first wrapped leg.
+    swap.fromTokenAmount = new BigNumber(ctx.txValue).gt(0)
+        ? ctx.txValue
+        : realAmount(amount, ctx.txValue);
+    swap.inputAmountLocked = true;
+};
+export const unwrapNative = (swap, ctx, recipient, minimum) => {
+    setOutput(swap, ctx, ctx.native, recipient, minimum);
+};
+export const finishSwap = (swap) => {
+    const payouts = Object.values(swap.payouts || {});
+    if (payouts.length > 1) {
+        throw new Error("Multiple output assets or recipients cannot be represented as a single swap result");
+    }
+    if (payouts.length === 1) {
+        swap.toToken = payouts[0].token;
+        swap.minReceive = payouts[0].minimum;
+        swap.receiver = payouts[0].receiver;
+    }
+    const required = [
+        "fromToken",
+        "fromTokenAmount",
+        "toToken",
+        "minReceive",
+        "receiver",
+    ];
+    const missing = required.filter((field) => !swap[field]);
+    if (missing.length) {
+        throw new Error(`Incomplete swap data: missing ${missing.join(", ")}`);
+    }
+    if (!new BigNumber(swap.fromTokenAmount).gt(0) ||
+        CONTRACT_BALANCE.eq(swap.fromTokenAmount)) {
+        throw new Error("Original input amount is zero or unresolved");
+    }
+    if (isSameAddress(swap.fromToken, swap.toToken)) {
+        throw new Error("The route does not describe a swap between two distinct assets");
+    }
+    return {
+        fromToken: swap.fromToken,
+        fromTokenAmount: swap.fromTokenAmount,
+        toToken: swap.toToken,
+        minReceiveToTokenAmount: swap.minReceive,
+        toTokenReceiver: swap.receiver,
+    };
+};

package/dist/calldata/uni/universalRouter/commands.d.ts

@@ -0,0 +1,3 @@
+import { Context, Swap } from "../shared";
+import type { RouterProfile } from "./profiles";
+export declare const walkCommands: (commands: string, inputs: string[], swap: Swap, ctx: Context, profile: RouterProfile) => void;