four-flap-meme-sdk 2.0.0 → 2.2.0

package/dist/utils/erc20/index.js

@@ -1,645 +0,0 @@
-import { Contract, Wallet, JsonRpcProvider, Interface, parseUnits } from 'ethers';
-import { ADDRESSES, ZERO_ADDRESS, getMulticall3Address } from '../constants.js';
-import { NonceManager } from '../bundle-helpers.js';
-import { ERC20_ABI, MULTICALL3_ABI } from '../../shared/abis/common.js';
-// ============================================================================
-// ✅ Max approval（与 BSC 策略一致：阈值判断，避免频繁重复授权）
-// ============================================================================
-const MAX_UINT256 = BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff');
-const MAX_APPROVAL_THRESHOLD = MAX_UINT256 / 2n;
-/**
- * 验证合约地址是否有效（是否部署了代码）
- */
-async function validateContractAddress(provider, address, label) {
-    try {
-        // ✅ 先规范化地址（转为 checksum 格式），避免 ethers v6 的严格校验报错
-        const normalizedAddress = address.toLowerCase().startsWith('0x')
-            ? address.toLowerCase()
-            : `0x${address.toLowerCase()}`;
-        const code = await provider.getCode(normalizedAddress);
-        if (code === '0x' || code.length <= 2) {
-            throw new Error(`❌ ${label} 地址无效或未部署合约: ${address}`);
-        }
-    }
-    catch (error) {
-        if (error.message.includes('无效或未部署')) {
-            throw error;
-        }
-        // ✅ 如果是 checksum 错误，提供更友好的提示
-        if (error.message.includes('bad address checksum') || error.code === 'INVALID_ARGUMENT') {
-            throw new Error(`❌ ${label} 地址格式错误，请使用正确的 checksum 格式: ${address}`);
-        }
-        throw new Error(`❌ 无法验证 ${label} 地址 ${address}: ${error.message}`);
-    }
-}
-/**
- * 通用 ERC20 授权方法（内部辅助函数）
- * 自动检查当前授权额度，只在不足时才发送交易
- */
-async function ensureAllowance(rpcUrl, privateKey, token, owner, spender, required) {
-    const provider = new JsonRpcProvider(rpcUrl);
-    const signer = new Wallet(privateKey, provider);
-    // ✅ 验证 token 和 spender 地址
-    await validateContractAddress(provider, token, 'Token');
-    await validateContractAddress(provider, spender, 'Spender');
-    const erc20 = new Contract(token, ERC20_ABI, signer);
-    // ✅ 自动检查当前授权额度，只在不足时才发送交易
-    let current;
-    try {
-        current = await erc20.allowance(owner, spender);
-    }
-    catch (error) {
-        throw new Error(`❌ 调用 allowance 失败（Token 可能不是 ERC20）: ${error.message}`);
-    }
-    if (current >= required) {
-        return {
-            alreadyApproved: true,
-            currentAllowance: current,
-            requiredAllowance: required,
-        };
-    }
-    const tx = await erc20.approve(spender, required);
-    const receipt = await tx.wait();
-    return {
-        alreadyApproved: false,
-        currentAllowance: current,
-        requiredAllowance: required,
-        txReceipt: receipt,
-    };
-}
-/**
- * 检查代币授权状态 - Four.meme V1（只读，不发送交易）
- * @returns 是否已授权足够的额度
- */
-export async function checkSellApprovalV1(chain, rpcUrl, token, owner, amount) {
-    const proxyAddresses = {
-        BSC: ADDRESSES.BSC.TokenManagerV1, // FourMeme 代理合约 V1 (BSC)
-        BASE: ADDRESSES.BASE.TokenManagerHelper3, // FourMeme 代理合约 (BASE)
-        ARBITRUM_ONE: ADDRESSES.ARBITRUM_ONE.TokenManagerHelper3, // FourMeme 代理合约 (ARBITRUM)
-    };
-    const provider = new JsonRpcProvider(rpcUrl);
-    // ✅ 验证 token 和代理合约地址
-    await validateContractAddress(provider, token, 'Token');
-    await validateContractAddress(provider, proxyAddresses[chain], `Four.meme V1 Proxy (${chain})`);
-    const erc20 = new Contract(token, ERC20_ABI, provider);
-    let current;
-    try {
-        current = await erc20.allowance(owner, proxyAddresses[chain]);
-    }
-    catch (error) {
-        throw new Error(`❌ 调用 allowance 失败（Token 可能不是 ERC20）: ${error.message}`);
-    }
-    return {
-        isApproved: current >= amount,
-        currentAllowance: current,
-        requiredAllowance: amount,
-    };
-}
-/**
- * 确保代币已授权给 Four.meme V1 代理合约
- * 用于 Four.meme V1 代币的卖出操作
- * @returns 授权结果，包含是否已授权、当前额度、交易回执等信息
- */
-export async function ensureSellApprovalV1(chain, rpcUrl, privateKey, token, owner, amount) {
-    // ✅ 授权给 FourMeme 代理合约 V1（收费版）
-    const proxyAddresses = {
-        BSC: ADDRESSES.BSC.TokenManagerV1, // FourMeme 代理合约 V1 (BSC)
-        BASE: ADDRESSES.BASE.TokenManagerHelper3, // FourMeme 代理合约 (BASE)
-        ARBITRUM_ONE: ADDRESSES.ARBITRUM_ONE.TokenManagerHelper3, // FourMeme 代理合约 (ARBITRUM)
-    };
-    return await ensureAllowance(rpcUrl, privateKey, token, owner, proxyAddresses[chain], amount);
-}
-/**
- * 检查代币授权状态 - Four.meme V2（只读，不发送交易）
- * @returns 是否已授权足够的额度
- */
-export async function checkSellApprovalV2(chain, rpcUrl, token, owner, amount) {
-    const proxyAddresses = {
-        BSC: ADDRESSES.BSC.TokenManagerV2, // FourMeme 代理合约 V2 (BSC)
-        BASE: ADDRESSES.BASE.TokenManagerHelper3, // FourMeme 代理合约 (BASE)
-        ARBITRUM_ONE: ADDRESSES.ARBITRUM_ONE.TokenManagerHelper3, // FourMeme 代理合约 (ARBITRUM)
-    };
-    const provider = new JsonRpcProvider(rpcUrl);
-    // ✅ 验证 token 和代理合约地址
-    await validateContractAddress(provider, token, 'Token');
-    await validateContractAddress(provider, proxyAddresses[chain], `Four.meme V2 Proxy (${chain})`);
-    const erc20 = new Contract(token, ERC20_ABI, provider);
-    let current;
-    try {
-        current = await erc20.allowance(owner, proxyAddresses[chain]);
-    }
-    catch (error) {
-        throw new Error(`❌ 调用 allowance 失败（Token 可能不是 ERC20）: ${error.message}`);
-    }
-    return {
-        isApproved: current >= amount,
-        currentAllowance: current,
-        requiredAllowance: amount,
-    };
-}
-/**
- * 确保代币已授权给 Four.meme V2 代理合约
- * 用于 Four.meme V2 代币的卖出操作
- * @returns 授权结果，包含是否已授权、当前额度、交易回执等信息
- */
-export async function ensureSellApprovalV2(chain, rpcUrl, privateKey, token, owner, amount) {
-    // ✅ 授权给 FourMeme 代理合约 V2（收费版）
-    const proxyAddresses = {
-        BSC: ADDRESSES.BSC.TokenManagerV2, // FourMeme 代理合约 V2 (BSC)
-        BASE: ADDRESSES.BASE.TokenManagerHelper3, // FourMeme 代理合约 (BASE)
-        ARBITRUM_ONE: ADDRESSES.ARBITRUM_ONE.TokenManagerHelper3, // FourMeme 代理合约 (ARBITRUM)
-    };
-    return await ensureAllowance(rpcUrl, privateKey, token, owner, proxyAddresses[chain], amount);
-}
-/**
- * 检查代币授权状态 - Four.meme（通用，默认使用 V2）
- * @deprecated 建议使用明确版本的方法：checkSellApprovalV1 或 checkSellApprovalV2
- */
-export async function checkSellApproval(chain, rpcUrl, token, owner, amount) {
-    return checkSellApprovalV2(chain, rpcUrl, token, owner, amount);
-}
-/**
- * 确保代币已授权给 Four.meme 代理合约（通用，默认使用 V2）
- * @deprecated 建议使用明确版本的方法：ensureSellApprovalV1 或 ensureSellApprovalV2
- */
-export async function ensureSellApproval(chain, rpcUrl, privateKey, token, owner, amount) {
-    return ensureSellApprovalV2(chain, rpcUrl, privateKey, token, owner, amount);
-}
-/**
- * 检查代币授权状态 - Flap Protocol（只读，不发送交易）
- * @returns 是否已授权足够的额度
- */
-export async function checkFlapSellApproval(chain, rpcUrl, token, owner, amount) {
-    const proxyAddresses = {
-        BSC: ADDRESSES.BSC.FlapPortal, // Flap Portal 代理合约 (BSC)
-        BASE: ADDRESSES.BASE.FlapPortal, // Flap Portal 代理合约 (BASE)
-        XLAYER: ADDRESSES.XLAYER.FlapPortal, // Flap Portal 代理合约 (XLAYER)
-        MORPH: ADDRESSES.MORPH.FlapPortal, // Flap Portal 代理合约 (MORPH)
-        MONAD: ADDRESSES.MONAD.FlapPortal, // Flap Portal 代理合约 (MONAD)
-    };
-    const provider = new JsonRpcProvider(rpcUrl);
-    // ✅ 验证 token 和代理合约地址
-    await validateContractAddress(provider, token, 'Token');
-    await validateContractAddress(provider, proxyAddresses[chain], `Flap Portal (${chain})`);
-    const erc20 = new Contract(token, ERC20_ABI, provider);
-    let current;
-    try {
-        current = await erc20.allowance(owner, proxyAddresses[chain]);
-    }
-    catch (error) {
-        throw new Error(`❌ 调用 allowance 失败（Token 可能不是 ERC20）: ${error.message}`);
-    }
-    return {
-        isApproved: current >= amount,
-        currentAllowance: current,
-        requiredAllowance: amount,
-    };
-}
-/**
- * 确保代币已授权给 Flap Protocol 代理合约
- * 用于 Flap Protocol 代币的卖出操作
- * @returns 授权结果，包含是否已授权、当前额度、交易回执等信息
- */
-export async function ensureFlapSellApproval(chain, rpcUrl, privateKey, token, owner, amount) {
-    // ✅ 授权给 Flap Portal 代理合约（收费版）
-    const proxyAddresses = {
-        BSC: ADDRESSES.BSC.FlapPortal, // Flap Portal 代理合约 (BSC)
-        BASE: ADDRESSES.BASE.FlapPortal, // Flap Portal 代理合约 (BASE)
-        XLAYER: ADDRESSES.XLAYER.FlapPortal, // Flap Portal 代理合约 (XLAYER)
-        MORPH: ADDRESSES.MORPH.FlapPortal, // Flap Portal 代理合约 (MORPH)
-        MONAD: ADDRESSES.MONAD.FlapPortal, // Flap Portal 代理合约 (MONAD)
-    };
-    return await ensureAllowance(rpcUrl, privateKey, token, owner, proxyAddresses[chain], amount);
-}
-/**
- * 批量确保代币已授权给 Flap Protocol 代理合约（默认授权上限 2^256-1）
- * @param privateKeys 拥有者私钥数组（每个地址需自行签名）
- * @returns 每个地址的授权结果（包含 owner 与交易回执等信息）
- */
-export async function ensureFlapSellApprovalBatch(chain, rpcUrl, privateKeys, token, required = BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')) {
-    if (!privateKeys || privateKeys.length === 0)
-        return [];
-    // ✅ 并行处理所有授权
-    const results = await Promise.all(privateKeys.map(async (pk) => {
-        const owner = new Wallet(pk).address;
-        const r = await ensureFlapSellApproval(chain, rpcUrl, pk, token, owner, required);
-        return { owner, ...r };
-    }));
-    return results;
-}
-/**
- * 批量检查 Flap Protocol 授权状态（默认按上限 2^256-1 判断）
- * ✅ 使用 Multicall3 批量查询，减少 RPC 调用次数
- */
-export async function checkFlapSellApprovalBatch(chain, rpcUrl, token, owners, required = BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')) {
-    if (!owners || owners.length === 0)
-        return [];
-    const proxyAddresses = {
-        BSC: ADDRESSES.BSC.FlapPortal,
-        BASE: ADDRESSES.BASE.FlapPortal,
-        XLAYER: ADDRESSES.XLAYER.FlapPortal,
-        MORPH: ADDRESSES.MORPH.FlapPortal,
-        MONAD: ADDRESSES.MONAD.FlapPortal,
-    };
-    const provider = new JsonRpcProvider(rpcUrl);
-    // ✅ 并行验证 token 和代理合约地址
-    await Promise.all([
-        validateContractAddress(provider, token, 'Token'),
-        validateContractAddress(provider, proxyAddresses[chain], `Flap Portal (${chain})`)
-    ]);
-    // ✅ 使用 batchCheckAllowances 批量查询（Multicall3）
-    const allowances = await batchCheckAllowances(provider, token, owners, proxyAddresses[chain]);
-    return owners.map((owner, i) => ({
-        owner,
-        isApproved: allowances[i] >= required,
-        currentAllowance: allowances[i],
-        requiredAllowance: required
-    }));
-}
-/**
- * 使用 Multicall3 批量查询 ERC20 授权额度
- * @param provider - Provider 实例
- * @param tokenAddress - ERC20 代币地址
- * @param owners - 所有者地址数组
- * @param spender - 被授权的 spender 地址
- * @returns 每个地址的授权额度数组
- */
-export async function batchCheckAllowances(provider, tokenAddress, owners, spender) {
-    const network = await provider.getNetwork();
-    const multicall3Address = getMulticall3Address(Number(network.chainId));
-    const multicall3 = new Contract(multicall3Address, MULTICALL3_ABI, provider);
-    // 编码 allowance(owner, spender) 调用数据
-    const erc20Interface = new Contract(tokenAddress, ERC20_ABI, provider).interface;
-    const calls = owners.map(owner => ({
-        target: tokenAddress,
-        allowFailure: true,
-        callData: erc20Interface.encodeFunctionData('allowance', [owner, spender])
-    }));
-    // 批量调用
-    const results = await multicall3.aggregate3(calls);
-    // 解析结果
-    return results.map((result, index) => {
-        if (!result.success) {
-            return 0n;
-        }
-        try {
-            const decoded = erc20Interface.decodeFunctionResult('allowance', result.returnData);
-            return decoded[0];
-        }
-        catch (error) {
-            return 0n;
-        }
-    });
-}
-/**
- * 🔧 内部辅助函数：根据链和平台自动解析 spender 地址
- */
-function resolveSpenderAddress(chain, platform) {
-    const spenderMap = {
-        flap: {
-            BSC: ADDRESSES.BSC.FlapPortal,
-            BASE: ADDRESSES.BASE.FlapPortal,
-            XLAYER: ADDRESSES.XLAYER.FlapPortal,
-            MORPH: ADDRESSES.MORPH.FlapPortal,
-            MONAD: ADDRESSES.MONAD.FlapPortal,
-            ENI: ZERO_ADDRESS,
-        },
-        four: {
-            BSC: ADDRESSES.BSC.TokenManagerOriginal,
-            BASE: ADDRESSES.BASE.TokenManagerHelper3,
-            XLAYER: ZERO_ADDRESS,
-            MORPH: ZERO_ADDRESS,
-            MONAD: ZERO_ADDRESS,
-            ENI: ZERO_ADDRESS,
-        },
-        'pancake-v2': {
-            BSC: ADDRESSES.BSC.PancakeV2Router,
-            BASE: '0x8cFe327CEc66d1C090Dd72bd0FF11d690C33a2Eb',
-            XLAYER: ZERO_ADDRESS,
-            MORPH: ZERO_ADDRESS,
-            MONAD: '0xb1bc24c34e88f7d43d5923034e3a14b24daacff9',
-            ENI: ZERO_ADDRESS,
-        },
-        'pancake-v3': {
-            BSC: ADDRESSES.BSC.PancakeV3Router,
-            BASE: '0x678Aa4bF4E210cf2166753e054d5b7c31cc7fa86',
-            XLAYER: ZERO_ADDRESS,
-            MORPH: ZERO_ADDRESS,
-            MONAD: '0x1b81d678ffb9c0263b24a97847620c99d213eb14',
-            ENI: ZERO_ADDRESS,
-        },
-        daoaas: {
-            BSC: ZERO_ADDRESS,
-            BASE: ZERO_ADDRESS,
-            XLAYER: ZERO_ADDRESS,
-            MORPH: ZERO_ADDRESS,
-            MONAD: ZERO_ADDRESS,
-            ENI: ADDRESSES.ENI.DaoaasPortal,
-        },
-        'dswap-v2': {
-            BSC: ZERO_ADDRESS,
-            BASE: ZERO_ADDRESS,
-            XLAYER: ZERO_ADDRESS,
-            MORPH: ZERO_ADDRESS,
-            MONAD: ZERO_ADDRESS,
-            ENI: ADDRESSES.ENI.DswapV2Router,
-        },
-    };
-    const spender = spenderMap[platform]?.[chain];
-    if (!spender || spender === ZERO_ADDRESS) {
-        throw new Error(`❌ 不支持的链或平台: ${chain} / ${platform}`);
-    }
-    return spender;
-}
-/**
- * ✅ 智能路由：检查单个 ERC20 授权额度（自动选择 spender）
- *
- * @param chain - 链名称 ('BSC' | 'BASE' | 'XLAYER' | 'MORPH' | 'MONAD')
- * @param platform - 平台名称 ('flap' | 'four' | 'pancake-v2' | 'pancake-v3')
- * @param rpcUrl - RPC 节点地址
- * @param tokenAddress - 代币合约地址
- * @param ownerAddress - 代币持有者地址
- * @returns 当前授权额度（bigint）
- */
-export async function checkAllowance(chain, platform, rpcUrl, tokenAddress, ownerAddress) {
-    const spenderAddress = resolveSpenderAddress(chain, platform);
-    return checkAllowanceRaw(rpcUrl, tokenAddress, ownerAddress, spenderAddress);
-}
-/**
- * ✅ 底层方法：检查 ERC20 代币授权额度（手动指定 spender）
- * 适用于任意 spender 地址（Flap、Four、PancakeSwap V2/V3 等）
- *
- * @param rpcUrl - RPC 节点地址
- * @param tokenAddress - 代币合约地址
- * @param ownerAddress - 代币持有者地址
- * @param spenderAddress - 被授权的合约地址（如 Router、Portal、TokenManager 等）
- * @returns 当前授权额度（bigint）
- */
-export async function checkAllowanceRaw(rpcUrl, tokenAddress, ownerAddress, spenderAddress) {
-    const provider = new JsonRpcProvider(rpcUrl);
-    // ✅ 规范化地址（转为小写，避免 checksum 错误）
-    const normalizedToken = tokenAddress.toLowerCase();
-    const normalizedOwner = ownerAddress.toLowerCase();
-    const normalizedSpender = spenderAddress.toLowerCase();
-    // 验证地址
-    await validateContractAddress(provider, normalizedToken, 'Token');
-    await validateContractAddress(provider, normalizedSpender, 'Spender');
-    const erc20 = new Contract(normalizedToken, ERC20_ABI, provider);
-    try {
-        const allowance = await erc20.allowance(normalizedOwner, normalizedSpender);
-        return allowance;
-    }
-    catch (error) {
-        throw new Error(`❌ 查询授权额度失败: ${error.message}`);
-    }
-}
-/**
- * ✅ 智能路由：授权 ERC20 代币（自动选择 spender，自动检查，只在不足时才发送交易）
- *
- * @param chain - 链名称 ('BSC' | 'BASE' | 'XLAYER' | 'MORPH' | 'MONAD')
- * @param platform - 平台名称 ('flap' | 'four' | 'pancake-v2' | 'pancake-v3')
- * @param rpcUrl - RPC 节点地址
- * @param privateKey - 私钥
- * @param tokenAddress - 代币合约地址
- * @param amount - 授权数量（bigint），传 'max' 表示最大授权
- * @returns 授权结果
- */
-export async function approveToken(chain, platform, rpcUrl, privateKey, tokenAddress, amount) {
-    const spenderAddress = resolveSpenderAddress(chain, platform);
-    return approveTokenRaw(rpcUrl, privateKey, tokenAddress, spenderAddress, amount);
-}
-/**
- * ✅ 底层方法：授权 ERC20 代币给指定合约（手动指定 spender）
- * 适用于任意 spender 地址（Flap、Four、PancakeSwap V2/V3 等）
- *
- * @param rpcUrl - RPC 节点地址
- * @param privateKey - 私钥
- * @param tokenAddress - 代币合约地址
- * @param spenderAddress - 被授权的合约地址（如 Router、Portal、TokenManager 等）
- * @param amount - 授权数量（bigint），传 'max' 或 ethers.MaxUint256 表示最大授权
- * @returns 授权结果
- */
-export async function approveTokenRaw(rpcUrl, privateKey, tokenAddress, spenderAddress, amount) {
-    const provider = new JsonRpcProvider(rpcUrl);
-    const signer = new Wallet(privateKey, provider);
-    const ownerAddress = signer.address;
-    // ✅ 规范化地址（转为小写，避免 checksum 错误）
-    const normalizedToken = tokenAddress.toLowerCase();
-    const normalizedSpender = spenderAddress.toLowerCase();
-    // 验证地址
-    await validateContractAddress(provider, normalizedToken, 'Token');
-    await validateContractAddress(provider, normalizedSpender, 'Spender');
-    const erc20 = new Contract(normalizedToken, ERC20_ABI, signer);
-    const isMax = amount === 'max';
-    const requiredAmount = isMax ? MAX_UINT256 : amount;
-    // 检查当前授权额度
-    let currentAllowance;
-    try {
-        currentAllowance = await erc20.allowance(ownerAddress, normalizedSpender);
-    }
-    catch (error) {
-        throw new Error(`❌ 查询授权额度失败: ${error.message}`);
-    }
-    // 如果已经授权足够，直接返回
-    // ✅ max 授权：使用阈值判断，避免每次消耗一点 allowance 都重新授权
-    if (isMax ? (currentAllowance >= MAX_APPROVAL_THRESHOLD) : (currentAllowance >= requiredAmount)) {
-        return {
-            alreadyApproved: true,
-            currentAllowance,
-            requiredAllowance: requiredAmount
-        };
-    }
-    // 发送授权交易
-    try {
-        const tx = await erc20.approve(normalizedSpender, requiredAmount);
-        const receipt = await tx.wait();
-        return {
-            alreadyApproved: false,
-            currentAllowance,
-            requiredAllowance: requiredAmount,
-            txReceipt: receipt
-        };
-    }
-    catch (error) {
-        throw new Error(`❌ 授权交易失败: ${error.message}`);
-    }
-}
-/**
- * ✅ 智能路由：批量检查多个钱包的授权额度（自动选择 spender）
- *
- * @param chain - 链名称 ('BSC' | 'BASE' | 'XLAYER' | 'MORPH' | 'MONAD')
- * @param platform - 平台名称 ('flap' | 'four' | 'pancake-v2' | 'pancake-v3')
- * @param rpcUrl - RPC 节点地址
- * @param tokenAddress - 代币合约地址
- * @param ownerAddresses - 代币持有者地址数组
- * @returns 每个地址的授权额度数组
- */
-export async function checkAllowanceBatch(chain, platform, rpcUrl, tokenAddress, ownerAddresses) {
-    const spenderAddress = resolveSpenderAddress(chain, platform);
-    return checkAllowanceBatchRaw(rpcUrl, tokenAddress, ownerAddresses, spenderAddress);
-}
-/**
- * ✅ 底层方法：批量检查多个钱包的授权额度（手动指定 spender）
- * 适用于任意 spender 地址（Flap、Four、PancakeSwap V2/V3 等）
- *
- * @param rpcUrl - RPC 节点地址
- * @param tokenAddress - 代币合约地址
- * @param ownerAddresses - 代币持有者地址数组
- * @param spenderAddress - 被授权的合约地址
- * @returns 每个地址的授权额度数组
- */
-export async function checkAllowanceBatchRaw(rpcUrl, tokenAddress, ownerAddresses, spenderAddress) {
-    const provider = new JsonRpcProvider(rpcUrl);
-    // ✅ 规范化地址（转为小写，避免 checksum 错误）
-    const normalizedToken = tokenAddress.toLowerCase();
-    const normalizedOwners = ownerAddresses.map(addr => addr.toLowerCase());
-    const normalizedSpender = spenderAddress.toLowerCase();
-    // 验证地址
-    await validateContractAddress(provider, normalizedToken, 'Token');
-    await validateContractAddress(provider, normalizedSpender, 'Spender');
-    return batchCheckAllowances(provider, normalizedToken, normalizedOwners, normalizedSpender);
-}
-export async function approveTokenBatch(params) {
-    const { chain, platform, rpcUrl, privateKeys, tokenAddress, amounts, signOnly, gasPriceGwei, gasLimit, chainId, skipValidation } = params;
-    const spenderAddress = resolveSpenderAddress(chain, platform);
-    return approveTokenBatchRaw({ rpcUrl, privateKeys, tokenAddress, spenderAddress, amounts, signOnly, gasPriceGwei, gasLimit, chainId, skipValidation });
-}
-export async function approveTokenBatchRaw(params) {
-    const { rpcUrl, privateKeys, tokenAddress, spenderAddress, amounts, signOnly, gasPriceGwei, gasLimit, chainId = 56, nonceManager: externalNonceManager, skipValidation } = params;
-    if (privateKeys.length === 0 || amounts.length !== privateKeys.length) {
-        throw new Error('❌ 私钥数量和授权数量必须匹配');
-    }
-    const provider = new JsonRpcProvider(rpcUrl);
-    // ✅ 规范化地址（转为小写，避免 checksum 错误）
-    const normalizedToken = tokenAddress.toLowerCase();
-    const normalizedSpender = spenderAddress.toLowerCase();
-    // 验证地址（如果 skipValidation=true 则跳过）
-    if (!skipValidation) {
-        await validateContractAddress(provider, normalizedToken, 'Token');
-        await validateContractAddress(provider, normalizedSpender, 'Spender');
-    }
-    // ✅ 优化：批量创建钱包和合约实例
-    const wallets = privateKeys.map(key => new Wallet(key, provider));
-    const ownerAddresses = wallets.map(w => w.address);
-    const isMaxApprovals = amounts.map(a => a === 'max');
-    const requiredAmounts = amounts.map(amount => amount === 'max'
-        ? MAX_UINT256
-        : amount);
-    // ==================== signOnly=true：只签名不提交 ====================
-    if (signOnly) {
-        // ✅ 使用 NonceManager 管理 nonce（和买卖交易一样）
-        const nonceManager = externalNonceManager || new NonceManager(provider);
-        // ✅ 并行获取：当前授权额度 + nonces + gasPrice
-        const [currentAllowances, nonces, fetchedGasPrice] = await Promise.all([
-            batchCheckAllowances(provider, normalizedToken, ownerAddresses, normalizedSpender),
-            nonceManager.getNextNoncesForWallets(wallets), // ✅ 使用 NonceManager 批量获取 nonce
-            gasPriceGwei ? Promise.resolve(parseUnits(gasPriceGwei.toString(), 'gwei')) : provider.getFeeData().then(fee => fee.gasPrice || parseUnits('3', 'gwei'))
-        ]);
-        const finalGasPrice = fetchedGasPrice;
-        const finalGasLimit = BigInt(gasLimit || 100000);
-        // ✅ ERC20 approve 函数的 ABI 编码
-        const erc20Interface = new Interface(ERC20_ABI);
-        // ✅ 并行签名所有需要授权的交易
-        const signPromises = wallets.map(async (wallet, i) => {
-            const ownerAddress = ownerAddresses[i];
-            const currentAllowance = currentAllowances[i];
-            const requiredAmount = requiredAmounts[i];
-            const isMax = isMaxApprovals[i];
-            // 如果已经授权足够，跳过
-            // ✅ max 授权：使用阈值判断（与 BSC 一致）
-            if (isMax ? (currentAllowance >= MAX_APPROVAL_THRESHOLD) : (currentAllowance >= requiredAmount)) {
-                return {
-                    owner: ownerAddress,
-                    alreadyApproved: true,
-                    currentAllowance,
-                    requiredAllowance: requiredAmount,
-                    signedTx: undefined
-                };
-            }
-            // 构建并签名交易
-            const txData = erc20Interface.encodeFunctionData('approve', [normalizedSpender, requiredAmount]);
-            const signedTx = await wallet.signTransaction({
-                to: normalizedToken,
-                data: txData,
-                nonce: nonces[i], // ✅ NonceManager 已经处理好递增
-                gasLimit: finalGasLimit,
-                gasPrice: finalGasPrice,
-                chainId,
-                type: 0 // Legacy 交易
-            });
-            return {
-                owner: ownerAddress,
-                alreadyApproved: false,
-                currentAllowance,
-                requiredAllowance: requiredAmount,
-                signedTx
-            };
-        });
-        const results = await Promise.all(signPromises);
-        // ✅ 提取所有签名交易（过滤掉已授权的）
-        const signedTransactions = results
-            .filter(r => !r.alreadyApproved && r.signedTx)
-            .map(r => r.signedTx);
-        const alreadyApprovedCount = results.filter(r => r.alreadyApproved).length;
-        const needApproveCount = results.filter(r => !r.alreadyApproved).length;
-        return {
-            signedTransactions,
-            results,
-            needApproveCount,
-            alreadyApprovedCount
-        };
-    }
-    // ==================== signOnly=false（默认）：直接发送交易 ====================
-    // ✅ 优化：并行检查所有钱包的授权额度
-    const currentAllowances = await batchCheckAllowances(provider, normalizedToken, ownerAddresses, normalizedSpender);
-    // ✅ 优化：并行发送所有需要授权的交易
-    const approvalPromises = wallets.map(async (wallet, i) => {
-        const ownerAddress = ownerAddresses[i];
-        const currentAllowance = currentAllowances[i];
-        const requiredAmount = requiredAmounts[i];
-        const isMax = isMaxApprovals[i];
-        try {
-            // 如果已经授权足够，跳过
-            // ✅ max 授权：使用阈值判断（与 BSC 一致）
-            if (isMax ? (currentAllowance >= MAX_APPROVAL_THRESHOLD) : (currentAllowance >= requiredAmount)) {
-                return {
-                    owner: ownerAddress,
-                    alreadyApproved: true,
-                    currentAllowance,
-                    requiredAllowance: requiredAmount
-                };
-            }
-            // 发送授权交易
-            const erc20 = new Contract(normalizedToken, ERC20_ABI, wallet);
-            const tx = await erc20.approve(normalizedSpender, requiredAmount);
-            const receipt = await tx.wait();
-            return {
-                owner: ownerAddress,
-                alreadyApproved: false,
-                currentAllowance,
-                requiredAllowance: requiredAmount,
-                txHash: receipt.hash
-            };
-        }
-        catch (error) {
-            return {
-                owner: ownerAddress,
-                alreadyApproved: false,
-                currentAllowance,
-                requiredAllowance: requiredAmount,
-                error: error.message
-            };
-        }
-    });
-    // ✅ 优化：并行等待所有授权交易完成
-    const results = await Promise.all(approvalPromises);
-    // 统计结果
-    const approvedCount = results.filter(r => !r.alreadyApproved && !r.error).length;
-    const errorCount = results.filter(r => r.error).length;
-    // ✅ 只要没有错误，就算成功（包括所有钱包都已授权的情况）
-    return {
-        success: errorCount === 0,
-        approvedCount,
-        results
-    };
-}