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

package/dist/abi.d.ts

@@ -335,3 +335,29 @@ 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;
+}[];

package/dist/abi.js

@@ -1652,3 +1652,53 @@ 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",
+    },
+];

package/dist/dexs/magpie.js

@@ -1,5 +1,8 @@
-import { CHAINS_ENUM } from "@debank/common";
-import { generateGetQuote } from "../utils";
+import { CHAINS, CHAINS_ENUM } from "@debank/common";
+import { Interface } from "@ethersproject/abi";
+import BigNumber from "bignumber.js";
+import { MagpieABI } from "../abi";
+import { generateGetQuote, isSameAddress, NULL_ADDRESS, resolveToTokenReceiver, } from "../utils";
 import { DEX_ENUM } from "../consts";
 export const SUPPORT_CHAINS = [
     CHAINS_ENUM.ETH,
@@ -37,6 +40,55 @@ export const getQuote = generateGetQuote({
     id: "magpie",
     dex: DEX_ENUM.MAGPIE,
 });
+const magpieInterface = new Interface(MagpieABI);
+// MagpieRouterV3 LibRouter.getData() 用绝对 calldata 偏移，不是 ABI tuple。
+// swapWithMagpieSignature(bytes) 标准编码下 bytes 从第 68 字节开始。
+const Packed = {
+    toAddress: 72,
+    fromAsset: 92,
+    toAsset: 112,
+    amountOutMin: { shift: 135, ptr: 136 },
+    amountIn: { shift: 141, ptr: 142 },
+};
+const readCompactUint = (hex, field) => {
+    const shiftBits = hex.slice(field.shift * 2, field.shift * 2 + 2);
+    const wordOffset = hex.slice(field.ptr * 2, field.ptr * 2 + 4);
+    if (shiftBits.length !== 2 || wordOffset.length !== 4)
+        return null;
+    const word = hex.slice(parseInt(wordOffset, 16) * 2, parseInt(wordOffset, 16) * 2 + 64);
+    if (word.length !== 64)
+        return null;
+    return new BigNumber(word, 16)
+        .idiv(new BigNumber(2).pow(parseInt(shiftBits, 16)))
+        .toFixed(0);
+};
 export const decodeCalldata = (tx) => {
-    return null;
+    const chain = Object.values(CHAINS).find((item) => item.id === tx.chainId);
+    if (!chain)
+        return null;
+    const result = magpieInterface.parseTransaction({ data: tx.data });
+    if (result.name !== "swapWithMagpieSignature")
+        return null;
+    const hex = tx.data.replace(/^0x/i, "").toLowerCase();
+    if (hex.length < (Packed.toAsset + 20) * 2)
+        return null;
+    const toAddress = `0x${hex.slice(Packed.toAddress * 2, (Packed.toAddress + 20) * 2)}`;
+    const fromAsset = `0x${hex.slice(Packed.fromAsset * 2, (Packed.fromAsset + 20) * 2)}`;
+    const toAsset = `0x${hex.slice(Packed.toAsset * 2, (Packed.toAsset + 20) * 2)}`;
+    const amountOutMin = readCompactUint(hex, Packed.amountOutMin);
+    const amountIn = readCompactUint(hex, Packed.amountIn);
+    if (!amountOutMin || !amountIn) {
+        return null;
+    }
+    return {
+        fromToken: isSameAddress(fromAsset, NULL_ADDRESS)
+            ? chain.nativeTokenAddress
+            : fromAsset,
+        fromTokenAmount: amountIn,
+        toToken: isSameAddress(toAsset, NULL_ADDRESS)
+            ? chain.nativeTokenAddress
+            : toAsset,
+        minReceiveToTokenAmount: amountOutMin,
+        toTokenReceiver: resolveToTokenReceiver(toAddress, tx.from),
+    };
 };

package/dist/dexs/uni.d.ts

@@ -1,5 +1,5 @@
 import { CHAINS_ENUM } from "@debank/common";
-import { TxWithChainId, DecodeCalldataResult } from "../quote";
+import { DecodeCalldataResult, TxWithChainId } from "../quote";
 export declare const SUPPORT_CHAINS: CHAINS_ENUM[];
 export declare const UNI_NATIVE_TO_ADDRESSES: Record<CHAINS_ENUM, string>;
 export declare const getQuote: (options: import("../quote").QuoteParams, api: import("@rabby-wallet/rabby-api").OpenApiService) => Promise<import("../quote").QuoteResult>;

package/dist/dexs/uni.js

@@ -1,5 +1,8 @@
-import { CHAINS_ENUM } from "@debank/common";
-import { generateGetQuote } from "../utils";
+import { CHAINS, CHAINS_ENUM } from "@debank/common";
+import { defaultAbiCoder, Interface } from "@ethersproject/abi";
+import BigNumber from "bignumber.js";
+import { UniABI } from "../abi";
+import { generateGetQuote, isSameAddress, NULL_ADDRESS } from "../utils";
 import { DEX_ENUM } from "../consts";
 export const SUPPORT_CHAINS = [
     CHAINS_ENUM.ETH,
@@ -40,6 +43,299 @@ export const getQuote = generateGetQuote({
     id: "uni",
     dex: DEX_ENUM.UNI,
 });
-export const decodeCalldata = (tx) => {
+const uniInterface = new Interface(UniABI);
+const MSG_SENDER = "0x0000000000000000000000000000000000000001";
+const ROUTER = "0x0000000000000000000000000000000000000002";
+const EETH = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+const CONTRACT_BALANCE = new BigNumber(2).pow(255);
+const COMMAND_MASK = 0x7f;
+const Command = {
+    V3_EXACT_IN: 0x00,
+    V3_EXACT_OUT: 0x01,
+    SWEEP: 0x04,
+    TRANSFER: 0x05,
+    V2_EXACT_IN: 0x08,
+    V2_EXACT_OUT: 0x09,
+    WRAP_ETH: 0x0b,
+    UNWRAP_WETH: 0x0c,
+    UNWRAP_WETH_EXACT: 0x0f,
+    V4_SWAP: 0x10,
+    SUB_PLAN: 0x21,
+};
+const V4 = {
+    EXACT_IN_SINGLE: 0x06,
+    EXACT_IN: 0x07,
+    EXACT_OUT_SINGLE: 0x08,
+    EXACT_OUT: 0x09,
+    TAKE: 0x0e,
+    TAKE_ALL: 0x0f,
+    TAKE_PAIR: 0x11,
+    SWEEP: 0x14,
+    WRAP: 0x15,
+    UNWRAP: 0x16,
+};
+const POOL_KEY = "tuple(address,address,uint24,int24,address)";
+const PATH_HOP = "tuple(address,uint24,int24,address,bytes)";
+const decode = (types, data) => {
+    try {
+        return defaultAbiCoder.decode(types, data);
+    }
+    catch (_a) {
+        return null;
+    }
+};
+const decodeAny = (variants, data) => {
+    for (const types of variants) {
+        const result = decode(types, data);
+        if (result)
+            return result;
+    }
     return null;
 };
+const chainToken = (token, native) => isSameAddress(token, NULL_ADDRESS) || isSameAddress(token, EETH)
+    ? native
+    : token;
+const realAmount = (amount, fallback) => CONTRACT_BALANCE.eq(amount) && fallback ? fallback : amount;
+const setSwap = (swap, ctx, fromToken, toToken, amountA, amountB, exactOut) => {
+    if (exactOut || !swap.wrappedNativeIn) {
+        swap.fromToken = chainToken(fromToken, ctx.native);
+    }
+    swap.toToken = chainToken(toToken, ctx.native);
+    swap.fromTokenAmount = exactOut
+        ? amountB
+        : realAmount(amountA, swap.fromTokenAmount || ctx.proxyAmount || ctx.txValue);
+    swap.minReceive = exactOut ? amountA : amountB;
+};
+const setReceiver = (swap, recipient, txFrom) => {
+    if (isSameAddress(recipient, ROUTER))
+        return;
+    const receiver = isSameAddress(recipient, MSG_SENDER) ? txFrom : recipient;
+    if (receiver)
+        swap.receiver = receiver;
+};
+const applyAmmSwap = (swap, ctx, input, exactOut, v3) => {
+    const result = decode(["address", "uint256", "uint256", v3 ? "bytes" : "address[]", "bool"], input);
+    if (!result)
+        return;
+    const [recipient, amountA, amountB, path] = result;
+    let tokens;
+    if (v3) {
+        // V3 path 是紧凑编码的 token + fee + token，不能按 address[] 解码。
+        const hex = path.replace(/^0x/i, "");
+        if (hex.length < 86)
+            return;
+        tokens = [`0x${hex.slice(0, 40)}`, `0x${hex.slice(-40)}`];
+    }
+    else {
+        tokens = path;
+        if (!(tokens === null || tokens === void 0 ? void 0 : tokens.length))
+            return;
+    }
+    const first = tokens[0];
+    const last = tokens[tokens.length - 1];
+    setSwap(swap, ctx, exactOut ? last : first, exactOut ? first : last, amountA.toString(), amountB.toString(), exactOut);
+    setReceiver(swap, recipient, ctx.txFrom);
+};
+const wrapNative = (swap, ctx, amount) => {
+    swap.wrappedNativeIn = true;
+    swap.fromToken = ctx.native;
+    swap.fromTokenAmount = realAmount(amount, ctx.txValue);
+};
+const unwrapNative = (swap, ctx, recipient, minOut) => {
+    swap.toToken = ctx.native;
+    swap.minReceive = minOut;
+    setReceiver(swap, recipient, ctx.txFrom);
+};
+const readV4Single = (params) => {
+    const decoded = decodeAny([
+        [POOL_KEY, "bool", "uint128", "uint128", "uint256", "bytes"],
+        [POOL_KEY, "bool", "uint128", "uint128", "bytes"],
+    ], params);
+    if (!decoded)
+        return null;
+    const pool = decoded[0];
+    const zeroForOne = Boolean(decoded[1]);
+    return {
+        fromToken: zeroForOne ? pool[0] : pool[1],
+        toToken: zeroForOne ? pool[1] : pool[0],
+        amountA: decoded[2].toString(),
+        amountB: decoded[3].toString(),
+    };
+};
+const readV4Path = (params, exactOut) => {
+    const decoded = decodeAny([
+        ["address", `${PATH_HOP}[]`, "uint256[]", "uint128", "uint128"],
+        ["address", `${PATH_HOP}[]`, "uint128", "uint128"],
+    ], params);
+    if (!decoded)
+        return null;
+    const path = decoded[1];
+    const lastHop = path[path.length - 1];
+    const end = (lastHop === null || lastHop === void 0 ? void 0 : lastHop.intermediateCurrency) || (lastHop === null || lastHop === void 0 ? void 0 : lastHop[0]);
+    if (!end)
+        return null;
+    const hasHopPrices = decoded.length === 5;
+    const amountA = (hasHopPrices ? decoded[3] : decoded[2]).toString();
+    const amountB = (hasHopPrices ? decoded[4] : decoded[3]).toString();
+    return exactOut
+        ? { fromToken: end, toToken: decoded[0], amountA, amountB }
+        : { fromToken: decoded[0], toToken: end, amountA, amountB };
+};
+const walkV4 = (swap, ctx, input) => {
+    const decoded = decode(["bytes", "bytes[]"], input);
+    if (!decoded)
+        return;
+    const actions = decoded[0].replace(/^0x/i, "");
+    const params = decoded[1];
+    for (let i = 0; i < actions.length / 2; i++) {
+        const action = parseInt(actions.slice(i * 2, i * 2 + 2), 16);
+        const data = params[i];
+        if (!data)
+            continue;
+        if (action === V4.EXACT_IN_SINGLE || action === V4.EXACT_IN ||
+            action === V4.EXACT_OUT_SINGLE || action === V4.EXACT_OUT) {
+            const exactOut = action === V4.EXACT_OUT_SINGLE || action === V4.EXACT_OUT;
+            const single = action === V4.EXACT_IN_SINGLE || action === V4.EXACT_OUT_SINGLE;
+            const parsed = single ? readV4Single(data) : readV4Path(data, exactOut);
+            if (parsed) {
+                setSwap(swap, ctx, parsed.fromToken, parsed.toToken, parsed.amountA, parsed.amountB, exactOut);
+            }
+        }
+        else if (action === V4.TAKE) {
+            const take = decode(["address", "address", "uint256"], data);
+            if (!take)
+                continue;
+            swap.toToken = chainToken(take[0], ctx.native);
+            setReceiver(swap, take[1], ctx.txFrom);
+        }
+        else if (action === V4.TAKE_ALL) {
+            const take = decode(["address", "uint256"], data);
+            if (!take)
+                continue;
+            swap.toToken = chainToken(take[0], ctx.native);
+            swap.minReceive = take[1].toString();
+            swap.receiver = ctx.txFrom;
+        }
+        else if (action === V4.TAKE_PAIR) {
+            const take = decode(["address", "address", "address"], data);
+            if (take)
+                setReceiver(swap, take[2], ctx.txFrom);
+        }
+        else if (action === V4.SWEEP) {
+            const sweep = decode(["address", "address", "uint256"], data);
+            if (!sweep)
+                continue;
+            swap.toToken = chainToken(sweep[0], ctx.native);
+            swap.minReceive = sweep[2].toString();
+            setReceiver(swap, sweep[1], ctx.txFrom);
+        }
+        else if (action === V4.WRAP) {
+            const wrap = decode(["address", "uint256"], data);
+            if (wrap)
+                wrapNative(swap, ctx, wrap[1].toString());
+        }
+        else if (action === V4.UNWRAP) {
+            const unwrap = decode(["address", "uint256"], data);
+            if (unwrap)
+                unwrapNative(swap, ctx, unwrap[0], unwrap[1].toString());
+        }
+    }
+};
+const walkCommands = (commands, inputs, ctx) => {
+    const swap = {};
+    if (ctx.proxyToken && !isSameAddress(ctx.proxyToken, NULL_ADDRESS)) {
+        swap.fromToken = ctx.proxyToken;
+    }
+    if (ctx.proxyAmount && ctx.proxyAmount !== "0") {
+        swap.fromTokenAmount = ctx.proxyAmount;
+    }
+    const cmdHex = (commands || "").replace(/^0x/i, "");
+    for (let i = 0; i < cmdHex.length / 2; i++) {
+        const command = parseInt(cmdHex.slice(i * 2, i * 2 + 2), 16) & COMMAND_MASK;
+        const input = inputs[i];
+        if (!input)
+            continue;
+        switch (command) {
+            case Command.V3_EXACT_IN:
+                applyAmmSwap(swap, ctx, input, false, true);
+                break;
+            case Command.V3_EXACT_OUT:
+                applyAmmSwap(swap, ctx, input, true, true);
+                break;
+            case Command.V2_EXACT_IN:
+                applyAmmSwap(swap, ctx, input, false, false);
+                break;
+            case Command.V2_EXACT_OUT:
+                applyAmmSwap(swap, ctx, input, true, false);
+                break;
+            case Command.WRAP_ETH: {
+                const wrap = decode(["address", "uint256"], input);
+                if (wrap)
+                    wrapNative(swap, ctx, wrap[1].toString());
+                break;
+            }
+            case Command.UNWRAP_WETH:
+            case Command.UNWRAP_WETH_EXACT: {
+                const unwrap = decode(["address", "uint256"], input);
+                if (unwrap)
+                    unwrapNative(swap, ctx, unwrap[0], unwrap[1].toString());
+                break;
+            }
+            case Command.SWEEP:
+            case Command.TRANSFER: {
+                const pay = decode(["address", "address", "uint256"], input);
+                if (!pay)
+                    break;
+                swap.toToken = chainToken(pay[0], ctx.native);
+                if (command === Command.SWEEP)
+                    swap.minReceive = pay[2].toString();
+                setReceiver(swap, pay[1], ctx.txFrom);
+                break;
+            }
+            case Command.V4_SWAP:
+                walkV4(swap, ctx, input);
+                break;
+            case Command.SUB_PLAN: {
+                const nested = decode(["bytes", "bytes[]"], input);
+                if (!nested)
+                    break;
+                Object.assign(swap, walkCommands(nested[0], nested[1], ctx));
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return swap;
+};
+export const decodeCalldata = (tx) => {
+    var _a;
+    const chain = Object.values(CHAINS).find((item) => item.id === tx.chainId);
+    if (!chain)
+        return null;
+    const result = uniInterface.parseTransaction({ data: tx.data });
+    if (result.name !== "execute")
+        return null;
+    const { commands, inputs, token, amount } = result.args;
+    const swap = walkCommands(commands, inputs, {
+        native: chain.nativeTokenAddress,
+        txFrom: tx.from,
+        proxyToken: token,
+        proxyAmount: amount === null || amount === void 0 ? void 0 : amount.toString(),
+        txValue: (_a = tx.value) === null || _a === void 0 ? void 0 : _a.toString(),
+    });
+    if (!swap.fromToken ||
+        !swap.fromTokenAmount ||
+        !swap.toToken ||
+        !swap.minReceive ||
+        !swap.receiver) {
+        return null;
+    }
+    return {
+        fromToken: swap.fromToken,
+        fromTokenAmount: swap.fromTokenAmount,
+        toToken: swap.toToken,
+        minReceiveToTokenAmount: swap.minReceive,
+        toTokenReceiver: swap.receiver,
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rabby-wallet/rabby-swap",
-  "version": "0.0.87",
+  "version": "0.0.88-alpha.0",
   "description": "",
   "main": "dist/index.js",
   "scripts": {