four-flap-meme-sdk 1.2.53 → 1.2.55

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export * as Abis from './abis/index.js';
 export { ADDRESSES, CHAIN } from './utils/constants.js';
 export { isExclusiveOnChain, isExclusiveOffChain } from './utils/mpcExclusive.js';
-export { ensureSellApprovalV1, checkSellApprovalV1, ensureSellApprovalV2, checkSellApprovalV2, ensureSellApproval, checkSellApproval, ensureFlapSellApproval, checkFlapSellApproval, ensureFlapSellApprovalBatch, checkFlapSellApprovalBatch, checkAllowance, approveToken, checkAllowanceBatch, approveTokenBatch, type EnsureAllowanceBatchItemResult, type ApproveTokenBatchParams, type ApproveTokenBatchResult } from './utils/erc20.js';
+export { ensureSellApprovalV1, checkSellApprovalV1, ensureSellApprovalV2, checkSellApprovalV2, ensureSellApproval, checkSellApproval, ensureFlapSellApproval, checkFlapSellApproval, ensureFlapSellApprovalBatch, checkFlapSellApprovalBatch, checkAllowance, approveToken, checkAllowanceBatch, approveTokenBatch, checkAllowanceRaw, approveTokenRaw, checkAllowanceBatchRaw, approveTokenBatchRaw, type EnsureAllowanceBatchItemResult, type ApproveTokenBatchParams, type ApproveTokenBatchRawParams, type ApproveTokenBatchResult } from './utils/erc20.js';
 export { parseFourError, type FourErrorCode } from './utils/errors.js';
 export { getTokenManagerV1, getTokenManagerV2, getTokenManagerHelper3, getTokenManagerV1Writer, getTokenManagerV2Writer, getTokenManagerHelper3Writer, getTokenManagerAddress, type ChainName } from './utils/contract-factory.js';
 export { FourClient, buildLoginMessage, type FourConfig, type GenerateNonceReq, type LoginReq, type CreateTokenReq, type CreateTokenResp } from './clients/four.js';

package/dist/index.js

@@ -10,8 +10,10 @@ ensureSellApprovalV2, checkSellApprovalV2,
 ensureSellApproval, checkSellApproval, 
 // Flap Protocol 授权
 ensureFlapSellApproval, checkFlapSellApproval, ensureFlapSellApprovalBatch, checkFlapSellApprovalBatch, 
-// ✅ 通用授权方法（适用于 Flap、Four、V2、V3 等所有场景）
-checkAllowance, approveToken, checkAllowanceBatch, approveTokenBatch } from './utils/erc20.js';
+// ✅ 智能路由授权方法（自动选择 spender，适用于 Flap、Four、V2、V3）
+checkAllowance, approveToken, checkAllowanceBatch, approveTokenBatch, 
+// ✅ 底层授权方法（手动指定 spender，适用于任意合约）
+checkAllowanceRaw, approveTokenRaw, checkAllowanceBatchRaw, approveTokenBatchRaw } from './utils/erc20.js';
 export { parseFourError } from './utils/errors.js';
 export { getTokenManagerV1, getTokenManagerV2, getTokenManagerHelper3, getTokenManagerV1Writer, getTokenManagerV2Writer, getTokenManagerHelper3Writer, getTokenManagerAddress } from './utils/contract-factory.js';
 export { FourClient, buildLoginMessage } from './clients/four.js';

package/dist/utils/erc20.d.ts

@@ -92,7 +92,18 @@ export declare function checkFlapSellApprovalBatch(chain: 'BSC' | 'BASE' | 'XLAY
  */
 export declare function batchCheckAllowances(provider: JsonRpcProvider, tokenAddress: string, owners: string[], spender: string): Promise<bigint[]>;
 /**
- * ✅ 通用方法：检查 ERC20 代币授权额度（只读，不发送交易）
+ * ✅ 智能路由：检查单个 ERC20 授权额度（自动选择 spender）
+ *
+ * @param chain - 链名称 ('BSC' | 'BASE' | 'XLAYER' | 'MORPH')
+ * @param platform - 平台名称 ('flap' | 'four' | 'pancake-v2' | 'pancake-v3')
+ * @param rpcUrl - RPC 节点地址
+ * @param tokenAddress - 代币合约地址
+ * @param ownerAddress - 代币持有者地址
+ * @returns 当前授权额度（bigint）
+ */
+export declare function checkAllowance(chain: 'BSC' | 'BASE' | 'XLAYER' | 'MORPH', platform: 'flap' | 'four' | 'pancake-v2' | 'pancake-v3', rpcUrl: string, tokenAddress: string, ownerAddress: string): Promise<bigint>;
+/**
+ * ✅ 底层方法：检查 ERC20 代币授权额度（手动指定 spender）
  * 适用于任意 spender 地址（Flap、Four、PancakeSwap V2/V3 等）
  *
  * @param rpcUrl - RPC 节点地址
@@ -101,9 +112,21 @@ export declare function batchCheckAllowances(provider: JsonRpcProvider, tokenAdd
  * @param spenderAddress - 被授权的合约地址（如 Router、Portal、TokenManager 等）
  * @returns 当前授权额度（bigint）
  */
-export declare function checkAllowance(rpcUrl: string, tokenAddress: string, ownerAddress: string, spenderAddress: string): Promise<bigint>;
+export declare function checkAllowanceRaw(rpcUrl: string, tokenAddress: string, ownerAddress: string, spenderAddress: string): Promise<bigint>;
 /**
- * ✅ 通用方法：授权 ERC20 代币给指定合约（自动检查，只在不足时才发送交易）
+ * ✅ 智能路由：授权 ERC20 代币（自动选择 spender，自动检查，只在不足时才发送交易）
+ *
+ * @param chain - 链名称 ('BSC' | 'BASE' | 'XLAYER' | 'MORPH')
+ * @param platform - 平台名称 ('flap' | 'four' | 'pancake-v2' | 'pancake-v3')
+ * @param rpcUrl - RPC 节点地址
+ * @param privateKey - 私钥
+ * @param tokenAddress - 代币合约地址
+ * @param amount - 授权数量（bigint），传 'max' 表示最大授权
+ * @returns 授权结果
+ */
+export declare function approveToken(chain: 'BSC' | 'BASE' | 'XLAYER' | 'MORPH', platform: 'flap' | 'four' | 'pancake-v2' | 'pancake-v3', rpcUrl: string, privateKey: string, tokenAddress: string, amount: bigint | 'max'): Promise<EnsureAllowanceResult>;
+/**
+ * ✅ 底层方法：授权 ERC20 代币给指定合约（手动指定 spender）
  * 适用于任意 spender 地址（Flap、Four、PancakeSwap V2/V3 等）
  *
  * @param rpcUrl - RPC 节点地址
@@ -113,9 +136,20 @@ export declare function checkAllowance(rpcUrl: string, tokenAddress: string, own
  * @param amount - 授权数量（bigint），传 'max' 或 ethers.MaxUint256 表示最大授权
  * @returns 授权结果
  */
-export declare function approveToken(rpcUrl: string, privateKey: string, tokenAddress: string, spenderAddress: string, amount: bigint | 'max'): Promise<EnsureAllowanceResult>;
+export declare function approveTokenRaw(rpcUrl: string, privateKey: string, tokenAddress: string, spenderAddress: string, amount: bigint | 'max'): Promise<EnsureAllowanceResult>;
 /**
- * ✅ 通用方法：批量检查多个钱包的授权额度（只读，不发送交易）
+ * ✅ 智能路由：批量检查多个钱包的授权额度（自动选择 spender）
+ *
+ * @param chain - 链名称 ('BSC' | 'BASE' | 'XLAYER' | 'MORPH')
+ * @param platform - 平台名称 ('flap' | 'four' | 'pancake-v2' | 'pancake-v3')
+ * @param rpcUrl - RPC 节点地址
+ * @param tokenAddress - 代币合约地址
+ * @param ownerAddresses - 代币持有者地址数组
+ * @returns 每个地址的授权额度数组
+ */
+export declare function checkAllowanceBatch(chain: 'BSC' | 'BASE' | 'XLAYER' | 'MORPH', platform: 'flap' | 'four' | 'pancake-v2' | 'pancake-v3', rpcUrl: string, tokenAddress: string, ownerAddresses: string[]): Promise<bigint[]>;
+/**
+ * ✅ 底层方法：批量检查多个钱包的授权额度（手动指定 spender）
  * 适用于任意 spender 地址（Flap、Four、PancakeSwap V2/V3 等）
  *
  * @param rpcUrl - RPC 节点地址
@@ -124,8 +158,16 @@ export declare function approveToken(rpcUrl: string, privateKey: string, tokenAd
  * @param spenderAddress - 被授权的合约地址
  * @returns 每个地址的授权额度数组
  */
-export declare function checkAllowanceBatch(rpcUrl: string, tokenAddress: string, ownerAddresses: string[], spenderAddress: string): Promise<bigint[]>;
+export declare function checkAllowanceBatchRaw(rpcUrl: string, tokenAddress: string, ownerAddresses: string[], spenderAddress: string): Promise<bigint[]>;
 export type ApproveTokenBatchParams = {
+    chain: 'BSC' | 'BASE' | 'XLAYER' | 'MORPH';
+    platform: 'flap' | 'four' | 'pancake-v2' | 'pancake-v3';
+    rpcUrl: string;
+    privateKeys: string[];
+    tokenAddress: string;
+    amounts: (bigint | 'max')[];
+};
+export type ApproveTokenBatchRawParams = {
     rpcUrl: string;
     privateKeys: string[];
     tokenAddress: string;
@@ -145,10 +187,17 @@ export type ApproveTokenBatchResult = {
     }>;
 };
 /**
- * ✅ 通用方法：批量授权 ERC20 代币（自动检查，只在不足时才发送交易）
- * 适用于任意 spender 地址（Flap、Four、PancakeSwap V2/V3 等）
+ * ✅ 智能路由：批量授权 ERC20 代币（自动选择 spender，自动检查，只在不足时才发送交易）
  *
  * @param params - 批量授权参数
  * @returns 批量授权结果
  */
 export declare function approveTokenBatch(params: ApproveTokenBatchParams): Promise<ApproveTokenBatchResult>;
+/**
+ * ✅ 底层方法：批量授权 ERC20 代币（手动指定 spender）
+ * 适用于任意 spender 地址（Flap、Four、PancakeSwap V2/V3 等）
+ *
+ * @param params - 批量授权参数
+ * @returns 批量授权结果
+ */
+export declare function approveTokenBatchRaw(params: ApproveTokenBatchRawParams): Promise<ApproveTokenBatchResult>;

package/dist/utils/erc20.js

@@ -11,7 +11,11 @@ const ERC20_ABI = [
  */
 async function validateContractAddress(provider, address, label) {
     try {
-        const code = await provider.getCode(address);
+        // ✅ 先规范化地址（转为 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}`);
         }
@@ -20,6 +24,10 @@ async function validateContractAddress(provider, address, label) {
         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}`);
     }
 }
@@ -205,7 +213,7 @@ export async function ensureFlapSellApproval(chain, rpcUrl, privateKey, token, o
  * @param privateKeys 拥有者私钥数组（每个地址需自行签名）
  * @returns 每个地址的授权结果（包含 owner 与交易回执等信息）
  */
-export async function ensureFlapSellApprovalBatch(chain, rpcUrl, privateKeys, token, required = ((1n << 256n) - 1n)) {
+export async function ensureFlapSellApprovalBatch(chain, rpcUrl, privateKeys, token, required = BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')) {
     const results = [];
     for (const pk of privateKeys || []) {
         const owner = new Wallet(pk).address;
@@ -217,7 +225,7 @@ export async function ensureFlapSellApprovalBatch(chain, rpcUrl, privateKeys, to
 /**
  * 批量检查 Flap Protocol 授权状态（默认按上限 2^256-1 判断）
  */
-export async function checkFlapSellApprovalBatch(chain, rpcUrl, token, owners, required = ((1n << 256n) - 1n)) {
+export async function checkFlapSellApprovalBatch(chain, rpcUrl, token, owners, required = BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')) {
     const proxyAddresses = {
         BSC: ADDRESSES.BSC.FlapPortal,
         BASE: ADDRESSES.BASE.FlapPortal,
@@ -280,7 +288,60 @@ export async function batchCheckAllowances(provider, tokenAddress, owners, spend
     });
 }
 /**
- * ✅ 通用方法：检查 ERC20 代币授权额度（只读，不发送交易）
+ * 🔧 内部辅助函数：根据链和平台自动解析 spender 地址
+ */
+function resolveSpenderAddress(chain, platform) {
+    const spenderMap = {
+        flap: {
+            BSC: ADDRESSES.BSC.FlapPortal,
+            BASE: ADDRESSES.BASE.FlapPortal,
+            XLAYER: ADDRESSES.XLAYER.FlapPortal,
+            MORPH: ADDRESSES.MORPH.FlapPortal,
+        },
+        four: {
+            // Four.meme 使用 TokenManagerV2Proxy（默认）
+            BSC: ADDRESSES.BSC.TokenManagerV2Proxy,
+            BASE: ADDRESSES.BASE.TokenManagerHelper3,
+            XLAYER: '0x0000000000000000000000000000000000000000', // XLAYER 暂不支持 Four.meme
+            MORPH: '0x0000000000000000000000000000000000000000', // MORPH 暂不支持 Four.meme
+        },
+        'pancake-v2': {
+            // PancakeSwap V2 Router 地址（需要在 constants.ts 中添加）
+            BSC: '0x10ED43C718714eb63d5aA57B78B54704E256024E', // BSC PancakeSwap V2 Router
+            BASE: '0x8cFe327CEc66d1C090Dd72bd0FF11d690C33a2Eb', // BASE PancakeSwap V2 Router
+            XLAYER: '0x0000000000000000000000000000000000000000', // XLAYER 暂不支持
+            MORPH: '0x0000000000000000000000000000000000000000', // MORPH 暂不支持
+        },
+        'pancake-v3': {
+            // PancakeSwap V3 SmartRouter 地址（需要在 constants.ts 中添加）
+            BSC: '0x13f4EA83D0bd40E75C8222255bc855a974568Dd4', // BSC PancakeSwap V3 SmartRouter
+            BASE: '0x678Aa4bF4E210cf2166753e054d5b7c31cc7fa86', // BASE PancakeSwap V3 SmartRouter
+            XLAYER: '0x0000000000000000000000000000000000000000', // XLAYER 暂不支持
+            MORPH: '0x0000000000000000000000000000000000000000', // MORPH 暂不支持
+        },
+    };
+    const spender = spenderMap[platform]?.[chain];
+    if (!spender || spender === '0x0000000000000000000000000000000000000000') {
+        throw new Error(`❌ 不支持的链或平台: ${chain} / ${platform}`);
+    }
+    return spender;
+}
+/**
+ * ✅ 智能路由：检查单个 ERC20 授权额度（自动选择 spender）
+ *
+ * @param chain - 链名称 ('BSC' | 'BASE' | 'XLAYER' | 'MORPH')
+ * @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 节点地址
@@ -289,14 +350,18 @@ export async function batchCheckAllowances(provider, tokenAddress, owners, spend
  * @param spenderAddress - 被授权的合约地址（如 Router、Portal、TokenManager 等）
  * @returns 当前授权额度（bigint）
  */
-export async function checkAllowance(rpcUrl, tokenAddress, ownerAddress, spenderAddress) {
+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, tokenAddress, 'Token');
-    await validateContractAddress(provider, spenderAddress, 'Spender');
-    const erc20 = new Contract(tokenAddress, ERC20_ABI, provider);
+    await validateContractAddress(provider, normalizedToken, 'Token');
+    await validateContractAddress(provider, normalizedSpender, 'Spender');
+    const erc20 = new Contract(normalizedToken, ERC20_ABI, provider);
     try {
-        const allowance = await erc20.allowance(ownerAddress, spenderAddress);
+        const allowance = await erc20.allowance(normalizedOwner, normalizedSpender);
         return allowance;
     }
     catch (error) {
@@ -304,7 +369,22 @@ export async function checkAllowance(rpcUrl, tokenAddress, ownerAddress, spender
     }
 }
 /**
- * ✅ 通用方法：授权 ERC20 代币给指定合约（自动检查，只在不足时才发送交易）
+ * ✅ 智能路由：授权 ERC20 代币（自动选择 spender，自动检查，只在不足时才发送交易）
+ *
+ * @param chain - 链名称 ('BSC' | 'BASE' | 'XLAYER' | 'MORPH')
+ * @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 节点地址
@@ -314,19 +394,22 @@ export async function checkAllowance(rpcUrl, tokenAddress, ownerAddress, spender
  * @param amount - 授权数量（bigint），传 'max' 或 ethers.MaxUint256 表示最大授权
  * @returns 授权结果
  */
-export async function approveToken(rpcUrl, privateKey, tokenAddress, spenderAddress, amount) {
+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, tokenAddress, 'Token');
-    await validateContractAddress(provider, spenderAddress, 'Spender');
-    const erc20 = new Contract(tokenAddress, ERC20_ABI, signer);
+    await validateContractAddress(provider, normalizedToken, 'Token');
+    await validateContractAddress(provider, normalizedSpender, 'Spender');
+    const erc20 = new Contract(normalizedToken, ERC20_ABI, signer);
     const requiredAmount = amount === 'max' ? BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff') : amount;
     // 检查当前授权额度
     let currentAllowance;
     try {
-        currentAllowance = await erc20.allowance(ownerAddress, spenderAddress);
+        currentAllowance = await erc20.allowance(ownerAddress, normalizedSpender);
     }
     catch (error) {
         throw new Error(`❌ 查询授权额度失败: ${error.message}`);
@@ -341,7 +424,7 @@ export async function approveToken(rpcUrl, privateKey, tokenAddress, spenderAddr
     }
     // 发送授权交易
     try {
-        const tx = await erc20.approve(spenderAddress, requiredAmount);
+        const tx = await erc20.approve(normalizedSpender, requiredAmount);
         const receipt = await tx.wait();
         return {
             alreadyApproved: false,
@@ -355,7 +438,21 @@ export async function approveToken(rpcUrl, privateKey, tokenAddress, spenderAddr
     }
 }
 /**
- * ✅ 通用方法：批量检查多个钱包的授权额度（只读，不发送交易）
+ * ✅ 智能路由：批量检查多个钱包的授权额度（自动选择 spender）
+ *
+ * @param chain - 链名称 ('BSC' | 'BASE' | 'XLAYER' | 'MORPH')
+ * @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 节点地址
@@ -364,29 +461,47 @@ export async function approveToken(rpcUrl, privateKey, tokenAddress, spenderAddr
  * @param spenderAddress - 被授权的合约地址
  * @returns 每个地址的授权额度数组
  */
-export async function checkAllowanceBatch(rpcUrl, tokenAddress, ownerAddresses, spenderAddress) {
+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, tokenAddress, 'Token');
-    await validateContractAddress(provider, spenderAddress, 'Spender');
-    return batchCheckAllowances(provider, tokenAddress, ownerAddresses, spenderAddress);
+    await validateContractAddress(provider, normalizedToken, 'Token');
+    await validateContractAddress(provider, normalizedSpender, 'Spender');
+    return batchCheckAllowances(provider, normalizedToken, normalizedOwners, normalizedSpender);
 }
 /**
- * ✅ 通用方法：批量授权 ERC20 代币（自动检查，只在不足时才发送交易）
- * 适用于任意 spender 地址（Flap、Four、PancakeSwap V2/V3 等）
+ * ✅ 智能路由：批量授权 ERC20 代币（自动选择 spender，自动检查，只在不足时才发送交易）
  *
  * @param params - 批量授权参数
  * @returns 批量授权结果
  */
 export async function approveTokenBatch(params) {
+    const { chain, platform, rpcUrl, privateKeys, tokenAddress, amounts } = params;
+    const spenderAddress = resolveSpenderAddress(chain, platform);
+    return approveTokenBatchRaw({ rpcUrl, privateKeys, tokenAddress, spenderAddress, amounts });
+}
+/**
+ * ✅ 底层方法：批量授权 ERC20 代币（手动指定 spender）
+ * 适用于任意 spender 地址（Flap、Four、PancakeSwap V2/V3 等）
+ *
+ * @param params - 批量授权参数
+ * @returns 批量授权结果
+ */
+export async function approveTokenBatchRaw(params) {
     const { rpcUrl, privateKeys, tokenAddress, spenderAddress, amounts } = 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();
     // 验证地址
-    await validateContractAddress(provider, tokenAddress, 'Token');
-    await validateContractAddress(provider, spenderAddress, 'Spender');
+    await validateContractAddress(provider, normalizedToken, 'Token');
+    await validateContractAddress(provider, normalizedSpender, 'Spender');
     const results = [];
     let approvedCount = 0;
     for (let i = 0; i < privateKeys.length; i++) {
@@ -396,9 +511,9 @@ export async function approveTokenBatch(params) {
             ? BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')
             : amounts[i];
         try {
-            const erc20 = new Contract(tokenAddress, ERC20_ABI, signer);
+            const erc20 = new Contract(normalizedToken, ERC20_ABI, signer);
             // 检查当前授权
-            const currentAllowance = await erc20.allowance(ownerAddress, spenderAddress);
+            const currentAllowance = await erc20.allowance(ownerAddress, normalizedSpender);
             if (currentAllowance >= requiredAmount) {
                 results.push({
                     owner: ownerAddress,
@@ -409,7 +524,7 @@ export async function approveTokenBatch(params) {
                 continue;
             }
             // 发送授权交易
-            const tx = await erc20.approve(spenderAddress, requiredAmount);
+            const tx = await erc20.approve(normalizedSpender, requiredAmount);
             const receipt = await tx.wait();
             results.push({
                 owner: ownerAddress,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "four-flap-meme-sdk",
-  "version": "1.2.53",
+  "version": "1.2.55",
   "description": "SDK for Flap bonding curve and four.meme TokenManager",
   "type": "module",
   "main": "dist/index.js",