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

package/dist/abi.d.ts

@@ -335,29 +335,5 @@ export declare const SushiABI: ({
     stateMutability: string;
     type: string;
 })[];
-export declare const UniABI: {
-    inputs: {
-        internalType: string;
-        name: string;
-        type: string;
-    }[];
-    name: string;
-    outputs: never[];
-    stateMutability: string;
-    type: string;
-}[];
-export declare const MagpieABI: {
-    inputs: {
-        internalType: string;
-        name: string;
-        type: string;
-    }[];
-    name: string;
-    outputs: {
-        internalType: string;
-        name: string;
-        type: string;
-    }[];
-    stateMutability: string;
-    type: string;
-}[];
+export { UniABI } from "./calldata/uni/abi";
+export { MagpieABI } from "./calldata/magpie/abi";

package/dist/abi.js

@@ -1652,53 +1652,5 @@ 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 const UniABI = [
-    {
-        inputs: [
-            { internalType: "bytes", name: "commands", type: "bytes" },
-            { internalType: "bytes[]", name: "inputs", type: "bytes[]" },
-        ],
-        name: "execute",
-        outputs: [],
-        stateMutability: "payable",
-        type: "function",
-    },
-    {
-        inputs: [
-            { internalType: "bytes", name: "commands", type: "bytes" },
-            { internalType: "bytes[]", name: "inputs", type: "bytes[]" },
-            { internalType: "uint256", name: "deadline", type: "uint256" },
-        ],
-        name: "execute",
-        outputs: [],
-        stateMutability: "payable",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "contract IUniversalRouter",
-                name: "router",
-                type: "address",
-            },
-            { internalType: "address", name: "token", type: "address" },
-            { internalType: "uint256", name: "amount", type: "uint256" },
-            { internalType: "bytes", name: "commands", type: "bytes" },
-            { internalType: "bytes[]", name: "inputs", type: "bytes[]" },
-            { internalType: "uint256", name: "deadline", type: "uint256" },
-        ],
-        name: "execute",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-];
-export const MagpieABI = [
-    {
-        inputs: [{ internalType: "bytes", name: "swapData", type: "bytes" }],
-        name: "swapWithMagpieSignature",
-        outputs: [{ internalType: "uint256", name: "amountOut", type: "uint256" }],
-        stateMutability: "payable",
-        type: "function",
-    },
-];
+export { UniABI } from "./calldata/uni/abi";
+export { MagpieABI } from "./calldata/magpie/abi";

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,30 @@
+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 fees paid in the input asset belong in its total debit.
+// 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);
+    }
+    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 { utils } from "ethers";
+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 utils.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 = utils.arrayify(transaction.args[0]).length;
+    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 { utils } from "ethers";
+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 utils.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;