four-flap-meme-sdk 1.2.89 → 1.2.91

package/dist/contracts/tm-bundle-merkle/types.d.ts

@@ -251,8 +251,6 @@ export type DisperseSignParams = {
         hopPrivateKeys?: string[];
     }>;
     config: FourSignConfig;
-    /** ✅ 起始 Nonce（用于并行调用时控制 nonce 顺序） */
-    startNonce?: number;
 };
 /**
  * ✅ 分发结果（简化版）
@@ -302,8 +300,6 @@ export type SweepSignParams = {
         hopPrivateKeys?: string[];
     }>;
     config: FourSignConfig;
-    /** ✅ 起始 Nonce（用于并行调用时控制 nonce 顺序 - 仅当有多个源钱包且使用同一私钥时有效，通常归集不需要） */
-    startNonce?: number;
 };
 /**
  * ✅ 归集结果（简化版）

package/dist/contracts/tm-bundle-merkle/utils.js

@@ -8,7 +8,7 @@ import { getErc20DecimalsMerkle as _getErc20DecimalsMerkle, generateHopWallets a
  * ✅ 精简版：只负责签名交易，不提交到 Merkle
  */
 export async function disperseWithBundleMerkle(params) {
-    const { fromPrivateKey, recipients, amount, amounts, tokenAddress, tokenDecimals, hopCount = 0, hopPrivateKeys, items, config, startNonce } = params;
+    const { fromPrivateKey, recipients, amount, amounts, tokenAddress, tokenDecimals, hopCount = 0, hopPrivateKeys, items, config } = params;
     // 快速返回空结果
     if (!recipients || recipients.length === 0) {
         return {
@@ -69,9 +69,6 @@ export async function disperseWithBundleMerkle(params) {
     if (!preparedHops) {
         // ========== 无多跳：直接批量转账 ==========
         const nonceManager = new NonceManager(provider);
-        if (startNonce !== undefined) {
-            nonceManager.setNonce(mainWallet.address, startNonce);
-        }
         const extraTxCount = extractProfit ? 1 : 0; // ✅ 利润转账需要额外1个nonce
         const nonces = await nonceManager.getNextNonceBatch(mainWallet, recipients.length + extraTxCount);
         if (isNative) {
@@ -161,9 +158,6 @@ export async function disperseWithBundleMerkle(params) {
         const iface = isNative ? null : new ethers.Interface(['function transfer(address,uint256) returns (bool)']);
         const gasFeePerHop = finalGasLimit * gasPrice;
         const nonceManager = new NonceManager(provider);
-        if (startNonce !== undefined) {
-            nonceManager.setNonce(mainWallet.address, startNonce);
-        }
         for (let i = 0; i < recipients.length; i++) {
             const finalRecipient = recipients[i];
             const originalAmountWei = isNative
@@ -321,7 +315,7 @@ export async function disperseWithBundleMerkle(params) {
  * ✅ 精简版：只负责签名交易，不提交到 Merkle
  */
 export async function sweepWithBundleMerkle(params) {
-    const { sourcePrivateKeys, target, ratioPct, ratios, amount, amounts, tokenAddress, tokenDecimals, skipIfInsufficient = true, hopCount = 0, hopPrivateKeys, sources, config, startNonce } = params;
+    const { sourcePrivateKeys, target, ratioPct, ratios, amount, amounts, tokenAddress, tokenDecimals, skipIfInsufficient = true, hopCount = 0, hopPrivateKeys, sources, config } = params;
     // 快速返回空结果
     if (!sourcePrivateKeys || sourcePrivateKeys.length === 0) {
         return {
@@ -389,10 +383,6 @@ export async function sweepWithBundleMerkle(params) {
         const wallets = actualKeys.map(pk => new Wallet(pk, provider));
         const addresses = wallets.map(w => w.address);
         const nonceManager = new NonceManager(provider);
-        // ✅ 如果提供了 startNonce，设置给第一个钱包（主要用于测试场景下单一源钱包的并发调用）
-        if (startNonce !== undefined && wallets.length > 0) {
-            nonceManager.setNonce(wallets[0].address, startNonce);
-        }
         if (isNative) {
             // ✅ 原生币：批量查询余额，统一扣除利润
             const balances = await _batchGetBalances(provider, addresses);
@@ -671,11 +661,6 @@ export async function sweepWithBundleMerkle(params) {
         const iface = isNative ? null : new ethers.Interface(['function transfer(address,uint256) returns (bool)']);
         const gasFeePerHop = finalGasLimit * gasPrice;
         const nonceManager = new NonceManager(provider);
-        // ✅ 如果提供了 startNonce，设置给第一个钱包（主要用于测试场景下单一源钱包的并发调用）
-        if (startNonce !== undefined && actualKeys.length > 0) {
-            const firstWallet = new Wallet(actualKeys[0], provider);
-            nonceManager.setNonce(firstWallet.address, startNonce);
-        }
         // 分离有跳转和无跳转的地址
         const sourceWallets = actualKeys.map(pk => new Wallet(pk, provider));
         const withHopIndexes = [];

package/dist/flap/constants.d.ts

@@ -8,6 +8,7 @@ export declare const FLAP_PORTAL_ADDRESSES: {
     readonly BASE: "0x00214f8C22A076575f4B67f3B4AA62f99E166e36";
     readonly XLAYER: "0xA4003509fD2053c07034D45e91EDeDa0ab4d2F8e";
     readonly MORPH: "0x6aB823408672c0Db1DE1a18F1750d62E5F995A58";
+    readonly MONAD: "0x30e8ee7b5881bf2E158A0514f2150aabe2c68b23";
 };
 /**
  * Flap Protocol 平台原始 Portal 合约地址
@@ -19,6 +20,7 @@ export declare const FLAP_ORIGINAL_PORTAL_ADDRESSES: {
     readonly BASE: "0xF3c514E04f83166E80718f29f0d34F206be40A0A";
     readonly XLAYER: "0xb30D8c4216E1f21F27444D2FfAee3ad577808678";
     readonly MORPH: "0x4267F317adee7C6478a5EE92985c2BD5D855E274";
+    readonly MONAD: "0x30e8ee7b5881bf2E158A0514f2150aabe2c68b23";
 };
 /**
  * Flap Protocol Token 实现合约地址
@@ -29,6 +31,8 @@ export declare const FLAP_TOKEN_IMPL_ADDRESSES: {
     readonly BASE: "0xF3c514E04f83166E80718f29f0d34F206be40A0A";
     readonly XLAYER: "0x12Dc83157Bf1cfCB8Db5952b3ba5bb56Cc38f8C9";
     readonly MORPH: "0x8b4329947e34b6d56d71a3385cac122bade7d78d";
+    readonly MONAD_NORMAL: "0xB88189aA1162850D75A1c1e16F837b7979994184";
+    readonly MONAD_TAXED: "0x1C8847736521f5cD725dFB8f33c7c610826e7C42";
 };
 /**
  * 不同链的默认手续费率
@@ -51,6 +55,10 @@ export declare const FLAP_DEFAULT_FEE_RATES: {
         readonly buy: 0.025;
         readonly sell: 0.025;
     };
+    readonly MONAD: {
+        readonly buy: 0.01;
+        readonly sell: 0.01;
+    };
 };
 /**
  * Flap IPFS API 端点

package/dist/flap/constants.js

@@ -8,6 +8,8 @@ export const FLAP_PORTAL_ADDRESSES = {
     BASE: '0x00214f8C22A076575f4B67f3B4AA62f99E166e36',
     XLAYER: '0xA4003509fD2053c07034D45e91EDeDa0ab4d2F8e',
     MORPH: '0x6aB823408672c0Db1DE1a18F1750d62E5F995A58',
+    // ✅ 新增 Monad 链 Portal 地址
+    MONAD: '0x30e8ee7b5881bf2E158A0514f2150aabe2c68b23',
 };
 /**
  * Flap Protocol 平台原始 Portal 合约地址
@@ -19,6 +21,8 @@ export const FLAP_ORIGINAL_PORTAL_ADDRESSES = {
     BASE: '0xF3c514E04f83166E80718f29f0d34F206be40A0A',
     XLAYER: '0xb30D8c4216E1f21F27444D2FfAee3ad577808678',
     MORPH: '0x4267F317adee7C6478a5EE92985c2BD5D855E274',
+    // ✅ 新增 Monad 链原始 Portal 地址
+    MONAD: '0x30e8ee7b5881bf2E158A0514f2150aabe2c68b23',
 };
 /**
  * Flap Protocol Token 实现合约地址
@@ -29,6 +33,9 @@ export const FLAP_TOKEN_IMPL_ADDRESSES = {
     BASE: '0xF3c514E04f83166E80718f29f0d34F206be40A0A',
     XLAYER: '0x12Dc83157Bf1cfCB8Db5952b3ba5bb56Cc38f8C9',
     MORPH: '0x8b4329947e34b6d56d71a3385cac122bade7d78d', // 暂时使用 BSC NORMAL 地址
+    // ✅ 新增 Monad 链 Token 实现地址
+    MONAD_NORMAL: '0xB88189aA1162850D75A1c1e16F837b7979994184',
+    MONAD_TAXED: '0x1C8847736521f5cD725dFB8f33c7c610826e7C42',
 };
 /**
  * 不同链的默认手续费率
@@ -39,6 +46,8 @@ export const FLAP_DEFAULT_FEE_RATES = {
     MORPH: { buy: 0.025, sell: 0.025 }, // 2.5% (250 bps)
     XLAYER: { buy: 0.015, sell: 0.015 }, // 1.5% (150 bps)
     BASE: { buy: 0.025, sell: 0.025 }, // 2.5% (默认)
+    // ✅ 新增 Monad 链默认费率
+    MONAD: { buy: 0.01, sell: 0.01 }, // 1% (100 bps) - 与 BSC 相同
 };
 /**
  * Flap IPFS API 端点

package/dist/flap/portal-bundle-merkle/config.d.ts

@@ -1,7 +1,9 @@
 import type { FlapBundleMerkleConfig, FlapSignConfig, FlapChainForMerkleBundle } from './types.js';
 export type { FlapBundleMerkleConfig, FlapSignConfig, FlapChainForMerkleBundle };
 export type FlapAnyConfig = FlapBundleMerkleConfig | FlapSignConfig;
-export declare const CHAIN_ID_MAP: Record<FlapChainForMerkleBundle, 56 | 1>;
+export declare const CHAIN_ID_MAP: Record<FlapChainForMerkleBundle, number>;
+export declare const MERKLE_SUPPORTED_CHAIN_IDS: readonly [56, 1];
+export type MerkleSupportedChainId = typeof MERKLE_SUPPORTED_CHAIN_IDS[number];
 export declare const PORTAL_ABI: string[];
 export declare const ERRORS: {
     NO_PRIVATE_KEY: {

package/dist/flap/portal-bundle-merkle/config.js

@@ -1,8 +1,14 @@
 import { ethers } from 'ethers';
 import { PROFIT_CONFIG } from '../../utils/constants.js';
+// ✅ Chain ID 映射
+// 注意：Merkle 捆绑服务目前只支持 BSC (56) 和 ETH (1)
+// Monad 不支持捆绑交易，这里的 143 仅用于非捆绑的签名交易
 export const CHAIN_ID_MAP = {
-    BSC: 56
+    BSC: 56,
+    MONAD: 143,
 };
+// Merkle 服务支持的 chainId（用于类型断言）
+export const MERKLE_SUPPORTED_CHAIN_IDS = [56, 1];
 // Portal ABI（统一交易接口）
 export const PORTAL_ABI = [
     'function newToken(string name, string symbol, string meta) external payable returns (address)',

package/dist/flap/portal-bundle-merkle/private.js

@@ -232,9 +232,22 @@ export async function flapBatchPrivateSellMerkle(params) {
 // ==================== 内部工具函数 ====================
 function createMerkleContext(chain, config) {
     const chainId = CHAIN_ID_MAP[chain];
+    // ✅ 检查是否为 Merkle 支持的链（BSC: 56, ETH: 1）
+    // Monad (143) 不支持 Merkle 捆绑服务，使用普通 RPC
+    if (chainId !== 56 && chainId !== 1) {
+        // 对于不支持 Merkle 的链（如 Monad），必须提供自定义 RPC
+        if (!config.customRpcUrl) {
+            throw new Error(`Chain ${chain} (chainId: ${chainId}) does not support Merkle bundle service. Please provide customRpcUrl.`);
+        }
+        const { JsonRpcProvider } = require('ethers');
+        return {
+            chainId,
+            provider: new JsonRpcProvider(config.customRpcUrl, { chainId, name: chain.toLowerCase() })
+        };
+    }
     const merkle = new MerkleClient({
         apiKey: config.apiKey,
-        chainId,
+        chainId: chainId, // 类型断言为 Merkle 支持的 chainId
         customRpcUrl: config.customRpcUrl
     });
     return {

package/dist/flap/portal-bundle-merkle/types.d.ts

@@ -24,7 +24,7 @@ export type FlapBundleMerkleConfig = {
     skipQuoteOnError?: boolean;
     skipSubmit?: boolean;
 };
-export type FlapChainForMerkleBundle = 'BSC';
+export type FlapChainForMerkleBundle = 'BSC' | 'MONAD';
 export type MerkleTransactionStatus = {
     index: number;
     hash: string;

package/dist/flap/portal.d.ts

@@ -74,7 +74,7 @@ export type TokenStateV5 = {
 /**
  * Flap Portal 支持的链
  */
-export type FlapChain = 'BSC' | 'BASE' | 'XLAYER' | 'MORPH';
+export type FlapChain = 'BSC' | 'BASE' | 'XLAYER' | 'MORPH' | 'MONAD';
 /**
  * Flap Portal 配置
  */

package/dist/pancake/bundle-swap.js

@@ -230,7 +230,34 @@ const PANCAKE_V3_QUOTER_ABI = [
     'function quoteExactInputSingle((address tokenIn, address tokenOut, uint256 amountIn, uint24 fee, uint160 sqrtPriceLimitX96)) external returns (uint256 amountOut, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate)',
     'function quoteExactInput(bytes memory path, uint256 amountIn) external returns (uint256 amountOut, uint160[] memory sqrtPriceX96AfterList, uint32[] memory initializedTicksCrossedList, uint256 gasEstimate)'
 ];
-// 地址
+const PANCAKE_CHAIN_ADDRESSES = {
+    BSC: {
+        PancakeProxy: ADDRESSES.BSC.PancakeProxy,
+        V2Router: '0x10ED43C718714eb63d5aA57B78B54704E256024E',
+        V3Router: '0x13f4EA83D0bd40E75C8222255bc855a974568Dd4',
+        V3Quoter: '0xB048Bbc1Ee6b733FFfCFb9e9CeF7375518e25997',
+        WETH: '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c',
+        chainId: 56,
+    },
+    MONAD: {
+        PancakeProxy: '0x20B89e7e088db3e06e0893Ce23162E475b9d8c7c', // ✅ 已部署
+        V2Router: '0xb1bc24c34e88f7d43d5923034e3a14b24daacff9',
+        V3Router: '0x1b81d678ffb9c0263b24a97847620c99d213eb14',
+        V3Quoter: '0xb048bbc1ee6b733fffcfb9e9cef7375518e25997',
+        WETH: '0x3bd359c1119da7da1d913d1c4d2b7c461115433a', // WMON
+        chainId: 143,
+    },
+};
+// ✅ 根据链获取地址
+function getChainAddresses(chainId) {
+    if (chainId === 56)
+        return PANCAKE_CHAIN_ADDRESSES.BSC;
+    if (chainId === 143)
+        return PANCAKE_CHAIN_ADDRESSES.MONAD;
+    // 默认返回 BSC
+    return PANCAKE_CHAIN_ADDRESSES.BSC;
+}
+// 兼容旧代码：默认使用 BSC 地址
 const PANCAKE_PROXY_ADDRESS = ADDRESSES.BSC.PancakeProxy;
 const PANCAKE_V2_ROUTER_ADDRESS = '0x10ED43C718714eb63d5aA57B78B54704E256024E';
 const PANCAKE_V3_QUOTER_ADDRESS = '0xB048Bbc1Ee6b733FFfCFb9e9CeF7375518e25997';

package/dist/utils/bundle-helpers.d.ts

@@ -16,12 +16,6 @@ export declare class NonceManager {
     private provider;
     private tempNonceCache;
     constructor(provider: JsonRpcProvider);
-    /**
-     * 手动设置缓存的 nonce（用于外部控制起始 nonce）
-     * @param wallet 钱包对象或地址
-     * @param nonce 起始 nonce（getNextNonce 将返回此值）
-     */
-    setNonce(wallet: Wallet | string, nonce: number): void;
     /**
      * 获取下一个可用的 nonce
      * @param wallet 钱包对象或地址

package/dist/utils/bundle-helpers.js

@@ -18,15 +18,6 @@ export class NonceManager {
         this.tempNonceCache = new Map();
         this.provider = provider;
     }
-    /**
-     * 手动设置缓存的 nonce（用于外部控制起始 nonce）
-     * @param wallet 钱包对象或地址
-     * @param nonce 起始 nonce（getNextNonce 将返回此值）
-     */
-    setNonce(wallet, nonce) {
-        const address = typeof wallet === 'string' ? wallet : wallet.address;
-        this.tempNonceCache.set(address.toLowerCase(), nonce);
-    }
     /**
      * 获取下一个可用的 nonce
      * @param wallet 钱包对象或地址

package/dist/utils/constants.d.ts

@@ -25,6 +25,10 @@ export declare const CHAIN: {
         chainId: number;
         name: string;
     };
+    MONAD: {
+        chainId: number;
+        name: string;
+    };
 };
 export declare const ADDRESSES: {
     readonly BSC: {
@@ -51,4 +55,13 @@ export declare const ADDRESSES: {
     readonly MORPH: {
         readonly FlapPortal: "0x6aB823408672c0Db1DE1a18F1750d62E5F995A58";
     };
+    readonly MONAD: {
+        readonly FlapPortal: "0x30e8ee7b5881bf2E158A0514f2150aabe2c68b23";
+        readonly TokenV2Implementation: "0xB88189aA1162850D75A1c1e16F837b7979994184";
+        readonly TaxTokenImplementation: "0x1C8847736521f5cD725dFB8f33c7c610826e7C42";
+        readonly TaxTokenSplitterImplementation: "0x57Fed6832F12150a77D5952b49190d9447aCB5ee";
+        readonly WMON: "0x3bd359c1119da7da1d913d1c4d2b7c461115433a";
+        readonly Multicall3: "0xca11bde05977b3631167028862be2a173976ca11";
+        readonly PancakeProxy: "0x20B89e7e088db3e06e0893Ce23162E475b9d8c7c";
+    };
 };

package/dist/utils/constants.js

@@ -14,6 +14,8 @@ export const CHAIN = {
     XLAYER: { chainId: 196, name: 'X Layer' },
     MORPH: { chainId: 2818, name: 'Morph' },
     ARBITRUM_ONE: { chainId: 42161, name: 'Arbitrum One' },
+    // ✅ 新增 Monad 链支持
+    MONAD: { chainId: 143, name: 'Monad' },
 };
 export const ADDRESSES = {
     BSC: {
@@ -50,4 +52,19 @@ export const ADDRESSES = {
         // Flap Portal 代理合约（收费版）
         FlapPortal: '0x6aB823408672c0Db1DE1a18F1750d62E5F995A58',
     },
+    // ✅ 新增 Monad 链合约地址
+    MONAD: {
+        // Flap Portal 合约（主入口）
+        FlapPortal: '0x30e8ee7b5881bf2E158A0514f2150aabe2c68b23',
+        // Token 实现合约
+        TokenV2Implementation: '0xB88189aA1162850D75A1c1e16F837b7979994184',
+        TaxTokenImplementation: '0x1C8847736521f5cD725dFB8f33c7c610826e7C42',
+        TaxTokenSplitterImplementation: '0x57Fed6832F12150a77D5952b49190d9447aCB5ee',
+        // 原生包装代币
+        WMON: '0x3bd359c1119da7da1d913d1c4d2b7c461115433a',
+        // Multicall3 合约
+        Multicall3: '0xca11bde05977b3631167028862be2a173976ca11',
+        // PancakeSwap 代理合约 ✅ 已部署
+        PancakeProxy: '0x20B89e7e088db3e06e0893Ce23162E475b9d8c7c',
+    },
 };

package/dist/utils/erc20.d.ts

@@ -56,7 +56,7 @@ export declare function ensureSellApproval(chain: 'BSC' | 'BASE' | 'ARBITRUM_ONE
  * 检查代币授权状态 - Flap Protocol（只读，不发送交易）
  * @returns 是否已授权足够的额度
  */
-export declare function checkFlapSellApproval(chain: 'BSC' | 'BASE' | 'XLAYER' | 'MORPH', rpcUrl: string, token: string, owner: string, amount: bigint): Promise<{
+export declare function checkFlapSellApproval(chain: 'BSC' | 'BASE' | 'XLAYER' | 'MORPH' | 'MONAD', rpcUrl: string, token: string, owner: string, amount: bigint): Promise<{
     isApproved: boolean;
     currentAllowance: bigint;
     requiredAllowance: bigint;
@@ -66,17 +66,17 @@ export declare function checkFlapSellApproval(chain: 'BSC' | 'BASE' | 'XLAYER' |
  * 用于 Flap Protocol 代币的卖出操作
  * @returns 授权结果，包含是否已授权、当前额度、交易回执等信息
  */
-export declare function ensureFlapSellApproval(chain: 'BSC' | 'BASE' | 'XLAYER' | 'MORPH', rpcUrl: string, privateKey: string, token: string, owner: string, amount: bigint): Promise<EnsureAllowanceResult>;
+export declare function ensureFlapSellApproval(chain: 'BSC' | 'BASE' | 'XLAYER' | 'MORPH' | 'MONAD', rpcUrl: string, privateKey: string, token: string, owner: string, amount: bigint): Promise<EnsureAllowanceResult>;
 /**
  * 批量确保代币已授权给 Flap Protocol 代理合约（默认授权上限 2^256-1）
  * @param privateKeys 拥有者私钥数组（每个地址需自行签名）
  * @returns 每个地址的授权结果（包含 owner 与交易回执等信息）
  */
-export declare function ensureFlapSellApprovalBatch(chain: 'BSC' | 'BASE' | 'XLAYER' | 'MORPH', rpcUrl: string, privateKeys: string[], token: string, required?: bigint): Promise<EnsureAllowanceBatchItemResult[]>;
+export declare function ensureFlapSellApprovalBatch(chain: 'BSC' | 'BASE' | 'XLAYER' | 'MORPH' | 'MONAD', rpcUrl: string, privateKeys: string[], token: string, required?: bigint): Promise<EnsureAllowanceBatchItemResult[]>;
 /**
  * 批量检查 Flap Protocol 授权状态（默认按上限 2^256-1 判断）
  */
-export declare function checkFlapSellApprovalBatch(chain: 'BSC' | 'BASE' | 'XLAYER' | 'MORPH', rpcUrl: string, token: string, owners: string[], required?: bigint): Promise<Array<{
+export declare function checkFlapSellApprovalBatch(chain: 'BSC' | 'BASE' | 'XLAYER' | 'MORPH' | 'MONAD', rpcUrl: string, token: string, owners: string[], required?: bigint): Promise<Array<{
     owner: string;
     isApproved: boolean;
     currentAllowance: bigint;
@@ -94,14 +94,14 @@ export declare function batchCheckAllowances(provider: JsonRpcProvider, tokenAdd
 /**
  * ✅ 智能路由：检查单个 ERC20 授权额度（自动选择 spender）
  *
- * @param chain - 链名称 ('BSC' | 'BASE' | 'XLAYER' | 'MORPH')
+ * @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 declare function checkAllowance(chain: 'BSC' | 'BASE' | 'XLAYER' | 'MORPH', platform: 'flap' | 'four' | 'pancake-v2' | 'pancake-v3', rpcUrl: string, tokenAddress: string, ownerAddress: string): Promise<bigint>;
+export declare function checkAllowance(chain: 'BSC' | 'BASE' | 'XLAYER' | 'MORPH' | 'MONAD', platform: 'flap' | 'four' | 'pancake-v2' | 'pancake-v3', rpcUrl: string, tokenAddress: string, ownerAddress: string): Promise<bigint>;
 /**
  * ✅ 底层方法：检查 ERC20 代币授权额度（手动指定 spender）
  * 适用于任意 spender 地址（Flap、Four、PancakeSwap V2/V3 等）
@@ -116,7 +116,7 @@ export declare function checkAllowanceRaw(rpcUrl: string, tokenAddress: string,
 /**
  * ✅ 智能路由：授权 ERC20 代币（自动选择 spender，自动检查，只在不足时才发送交易）
  *
- * @param chain - 链名称 ('BSC' | 'BASE' | 'XLAYER' | 'MORPH')
+ * @param chain - 链名称 ('BSC' | 'BASE' | 'XLAYER' | 'MORPH' | 'MONAD')
  * @param platform - 平台名称 ('flap' | 'four' | 'pancake-v2' | 'pancake-v3')
  * @param rpcUrl - RPC 节点地址
  * @param privateKey - 私钥
@@ -124,7 +124,7 @@ export declare function checkAllowanceRaw(rpcUrl: string, tokenAddress: string,
  * @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>;
+export declare function approveToken(chain: 'BSC' | 'BASE' | 'XLAYER' | 'MORPH' | 'MONAD', 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 等）
@@ -140,14 +140,14 @@ export declare function approveTokenRaw(rpcUrl: string, privateKey: string, toke
 /**
  * ✅ 智能路由：批量检查多个钱包的授权额度（自动选择 spender）
  *
- * @param chain - 链名称 ('BSC' | 'BASE' | 'XLAYER' | 'MORPH')
+ * @param chain - 链名称 ('BSC' | 'BASE' | 'XLAYER' | 'MORPH' | 'MONAD')
  * @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[]>;
+export declare function checkAllowanceBatch(chain: 'BSC' | 'BASE' | 'XLAYER' | 'MORPH' | 'MONAD', platform: 'flap' | 'four' | 'pancake-v2' | 'pancake-v3', rpcUrl: string, tokenAddress: string, ownerAddresses: string[]): Promise<bigint[]>;
 /**
  * ✅ 底层方法：批量检查多个钱包的授权额度（手动指定 spender）
  * 适用于任意 spender 地址（Flap、Four、PancakeSwap V2/V3 等）
@@ -160,7 +160,7 @@ export declare function checkAllowanceBatch(chain: 'BSC' | 'BASE' | 'XLAYER' | '
  */
 export declare function checkAllowanceBatchRaw(rpcUrl: string, tokenAddress: string, ownerAddresses: string[], spenderAddress: string): Promise<bigint[]>;
 export type ApproveTokenBatchParams = {
-    chain: 'BSC' | 'BASE' | 'XLAYER' | 'MORPH';
+    chain: 'BSC' | 'BASE' | 'XLAYER' | 'MORPH' | 'MONAD';
     platform: 'flap' | 'four' | 'pancake-v2' | 'pancake-v3';
     rpcUrl: string;
     privateKeys: string[];

package/dist/utils/erc20.js

@@ -174,6 +174,7 @@ export async function checkFlapSellApproval(chain, rpcUrl, token, owner, amount)
         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 和代理合约地址
@@ -205,6 +206,7 @@ export async function ensureFlapSellApproval(chain, rpcUrl, privateKey, token, o
         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);
 }
@@ -231,6 +233,7 @@ export async function checkFlapSellApprovalBatch(chain, rpcUrl, token, owners, r
         BASE: ADDRESSES.BASE.FlapPortal,
         XLAYER: ADDRESSES.XLAYER.FlapPortal,
         MORPH: ADDRESSES.MORPH.FlapPortal,
+        MONAD: ADDRESSES.MONAD.FlapPortal,
     };
     const provider = new JsonRpcProvider(rpcUrl);
     // ✅ 验证 token 和代理合约地址
@@ -259,7 +262,8 @@ export async function checkFlapSellApprovalBatch(chain, rpcUrl, token, owners, r
  * @returns 每个地址的授权额度数组
  */
 export async function batchCheckAllowances(provider, tokenAddress, owners, spender) {
-    const multicall3Address = ADDRESSES.BSC.Multicall3;
+    // ✅ 动态获取 Multicall3 地址（所有链使用相同地址）
+    const multicall3Address = '0xca11bde05977b3631167028862be2a173976ca11';
     const multicall3ABI = [
         'function aggregate3(tuple(address target, bool allowFailure, bytes callData)[] calls) view returns (tuple(bool success, bytes returnData)[] returnData)'
     ];
@@ -297,6 +301,7 @@ function resolveSpenderAddress(chain, platform) {
             BASE: ADDRESSES.BASE.FlapPortal,
             XLAYER: ADDRESSES.XLAYER.FlapPortal,
             MORPH: ADDRESSES.MORPH.FlapPortal,
+            MONAD: ADDRESSES.MONAD.FlapPortal, // ✅ Monad Flap Portal
         },
         four: {
             // Four.meme 使用 TokenManagerV2Proxy（默认）
@@ -304,20 +309,23 @@ function resolveSpenderAddress(chain, platform) {
             BASE: ADDRESSES.BASE.TokenManagerHelper3,
             XLAYER: '0x0000000000000000000000000000000000000000', // XLAYER 暂不支持 Four.meme
             MORPH: '0x0000000000000000000000000000000000000000', // MORPH 暂不支持 Four.meme
+            MONAD: '0x0000000000000000000000000000000000000000', // ❌ MONAD 不支持 Four.meme
         },
         'pancake-v2': {
-            // PancakeSwap V2 Router 地址（需要在 constants.ts 中添加）
+            // PancakeSwap V2 Router 地址
             BSC: '0x10ED43C718714eb63d5aA57B78B54704E256024E', // BSC PancakeSwap V2 Router
             BASE: '0x8cFe327CEc66d1C090Dd72bd0FF11d690C33a2Eb', // BASE PancakeSwap V2 Router
             XLAYER: '0x0000000000000000000000000000000000000000', // XLAYER 暂不支持
             MORPH: '0x0000000000000000000000000000000000000000', // MORPH 暂不支持
+            MONAD: '0xb1bc24c34e88f7d43d5923034e3a14b24daacff9', // ✅ Monad PancakeSwap V2 Router
         },
         'pancake-v3': {
-            // PancakeSwap V3 SmartRouter 地址（需要在 constants.ts 中添加）
+            // PancakeSwap V3 SmartRouter 地址
             BSC: '0x13f4EA83D0bd40E75C8222255bc855a974568Dd4', // BSC PancakeSwap V3 SmartRouter
             BASE: '0x678Aa4bF4E210cf2166753e054d5b7c31cc7fa86', // BASE PancakeSwap V3 SmartRouter
             XLAYER: '0x0000000000000000000000000000000000000000', // XLAYER 暂不支持
             MORPH: '0x0000000000000000000000000000000000000000', // MORPH 暂不支持
+            MONAD: '0x1b81d678ffb9c0263b24a97847620c99d213eb14', // ✅ Monad PancakeSwap V3 Router
         },
     };
     const spender = spenderMap[platform]?.[chain];
@@ -329,7 +337,7 @@ function resolveSpenderAddress(chain, platform) {
 /**
  * ✅ 智能路由：检查单个 ERC20 授权额度（自动选择 spender）
  *
- * @param chain - 链名称 ('BSC' | 'BASE' | 'XLAYER' | 'MORPH')
+ * @param chain - 链名称 ('BSC' | 'BASE' | 'XLAYER' | 'MORPH' | 'MONAD')
  * @param platform - 平台名称 ('flap' | 'four' | 'pancake-v2' | 'pancake-v3')
  * @param rpcUrl - RPC 节点地址
  * @param tokenAddress - 代币合约地址
@@ -371,7 +379,7 @@ export async function checkAllowanceRaw(rpcUrl, tokenAddress, ownerAddress, spen
 /**
  * ✅ 智能路由：授权 ERC20 代币（自动选择 spender，自动检查，只在不足时才发送交易）
  *
- * @param chain - 链名称 ('BSC' | 'BASE' | 'XLAYER' | 'MORPH')
+ * @param chain - 链名称 ('BSC' | 'BASE' | 'XLAYER' | 'MORPH' | 'MONAD')
  * @param platform - 平台名称 ('flap' | 'four' | 'pancake-v2' | 'pancake-v3')
  * @param rpcUrl - RPC 节点地址
  * @param privateKey - 私钥
@@ -440,7 +448,7 @@ export async function approveTokenRaw(rpcUrl, privateKey, tokenAddress, spenderA
 /**
  * ✅ 智能路由：批量检查多个钱包的授权额度（自动选择 spender）
  *
- * @param chain - 链名称 ('BSC' | 'BASE' | 'XLAYER' | 'MORPH')
+ * @param chain - 链名称 ('BSC' | 'BASE' | 'XLAYER' | 'MORPH' | 'MONAD')
  * @param platform - 平台名称 ('flap' | 'four' | 'pancake-v2' | 'pancake-v3')
  * @param rpcUrl - RPC 节点地址
  * @param tokenAddress - 代币合约地址

package/dist/utils/lp-inspect.d.ts

@@ -28,7 +28,7 @@ export type LPInfo = {
         };
     };
     v3?: Array<{
-        base: 'WBNB' | 'USDT';
+        base: 'WBNB' | 'USDT' | 'WMON' | 'USDC';
         fee: number;
         pool: string;
         tokenBalance: string;
@@ -36,7 +36,7 @@ export type LPInfo = {
     }>;
 };
 export type InspectOptions = {
-    chain: 'BSC';
+    chain: 'BSC' | 'MONAD';
     rpcUrl: string;
     flapChain?: FlapChain;
     v3FeeTiers?: Array<number>;

package/dist/utils/lp-inspect.js

@@ -2,11 +2,27 @@ import { Contract, JsonRpcProvider, Interface, formatUnits } from 'ethers';
 import { ADDRESSES } from './constants.js';
 import { Helper3 } from '../contracts/helper3.js';
 import { FlapPortal } from '../flap/portal.js';
-// 常量：BSC 常用代币与工厂（可按需扩展链）
+// 常量：各链常用代币与工厂
 const TOKENS = {
     BSC: {
-        WBNB: '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c', // 修复 checksum: 第3个字符应该是小写 b
+        WBNB: '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c',
         USDT: '0x55d398326f99059fF775485246999027B3197955',
+    },
+    // ✅ Monad 链代币
+    MONAD: {
+        WMON: '0x3bd359c1119da7da1d913d1c4d2b7c461115433a', // Wrapped MON
+        USDC: '0x754704bc059f8c67012fed69bc8a327a5aafb603', // USDC on Monad
+    }
+};
+// ✅ 各链 PancakeSwap 工厂地址
+const PANCAKE_FACTORIES = {
+    BSC: {
+        v2: '0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73',
+        v3: '0x0BFbCF9fa4f9C56B0F40a671Ad40E0805A091865',
+    },
+    MONAD: {
+        v2: '0x44c90b66eb4c4f814cea6aaf2ac71ca88fa77308', // Monad PancakeSwap V2 Factory
+        v3: '0x40ce898c43df68c8c4229cd5ce21d3ce1f3ddcf1', // Monad PancakeSwap V3 Factory
     }
 };
 // Pancake V2/V3 工厂（BSC，作兜底）
@@ -50,6 +66,24 @@ export async function inspectTokenLP(token, opts) {
             multicall3 = '0xca11bde05977b3631167028862be2a173976ca11';
         }
     }
+    // ✅ 获取当前链的原生包装代币和稳定币地址
+    function getChainTokens() {
+        if (opts.chain === 'MONAD') {
+            return {
+                wrappedNative: TOKENS.MONAD.WMON,
+                wrappedNativeSymbol: 'WMON',
+                stableCoin: TOKENS.MONAD.USDC,
+                stableCoinSymbol: 'USDC',
+            };
+        }
+        // 默认 BSC
+        return {
+            wrappedNative: TOKENS.BSC.WBNB,
+            wrappedNativeSymbol: 'WBNB',
+            stableCoin: TOKENS.BSC.USDT,
+            stableCoinSymbol: 'USDT',
+        };
+    }
     async function resolveFactories() {
         // 1) 直接给出工厂
         if (opts.factoryV2 && opts.factoryV3)
@@ -70,19 +104,22 @@ export async function inspectTokenLP(token, opts) {
             }
         }
         catch { }
-        // 3) 通过 Helper3 读取（four 平台内置常量）
-        try {
-            const helper = Helper3.connectByChain(opts.chain, opts.rpcUrl);
-            if (!res.v2 && helper.PANCAKE_FACTORY)
-                res.v2 = await helper.PANCAKE_FACTORY();
-            if (!res.v3 && helper.PANCAKE_V3_FACTORY)
-                res.v3 = await helper.PANCAKE_V3_FACTORY();
+        // 3) ✅ 只在 BSC 链上通过 Helper3 读取（Four.meme 只支持 BSC）
+        if (opts.chain === 'BSC') {
+            try {
+                const helper = Helper3.connectByChain('BSC', opts.rpcUrl);
+                if (!res.v2 && helper.PANCAKE_FACTORY)
+                    res.v2 = await helper.PANCAKE_FACTORY();
+                if (!res.v3 && helper.PANCAKE_V3_FACTORY)
+                    res.v3 = await helper.PANCAKE_V3_FACTORY();
+            }
+            catch { }
         }
-        catch { }
-        // 4) 兜底常量
+        // 4) ✅ 根据链使用对应的工厂地址
+        const chainFactories = PANCAKE_FACTORIES[opts.chain] || PANCAKE_FACTORIES.BSC;
         return {
-            v2: res.v2 || PANCAKE_V2_FACTORY_FALLBACK,
-            v3: res.v3 || PANCAKE_V3_FACTORY_FALLBACK,
+            v2: res.v2 || chainFactories.v2,
+            v3: res.v3 || chainFactories.v3,
         };
     }
     // 1) flap 内盘优先识别（如提供 flapChain）
@@ -108,46 +145,50 @@ export async function inspectTokenLP(token, opts) {
         }
         catch { }
     }
-    // 2) four 内盘识别（严格条件）
-    try {
-        const helper = Helper3.connectByChain(opts.chain, opts.rpcUrl);
-        const info = await helper.getTokenInfo(token);
-        if (info) {
-            const tokenManager = info.tokenManager;
-            const versionNum = Number(info.version ?? 0);
-            const liquidityAdded = Boolean(info.liquidityAdded);
-            const isValid = tokenManager && tokenManager !== '0x0000000000000000000000000000000000000000' && (versionNum === 1 || versionNum === 2);
-            if (isValid) {
-                // 若已添加流动性（已上 DEX），则继续外盘检测
-                if (!liquidityAdded) {
-                    out.platform = 'FOUR';
-                    out.decimals = tokenDecimals;
-                    const reserveNative = info.funds !== undefined ? formatBalance(info.funds, shouldFormat) : undefined;
-                    const offerTokens = info.offers !== undefined ? formatBalance(info.offers, shouldFormat) : undefined;
-                    const lastPrice = info.lastPrice !== undefined ? formatBalance(info.lastPrice, shouldFormat) : undefined;
-                    out.four = { helper: ADDRESSES[opts.chain].TokenManagerHelper3, reserveNative, offerTokens, lastPrice };
-                    return out;
+    // 2) four 内盘识别（严格条件）- ✅ 只在 BSC 链上执行（Monad 不支持 Four.meme）
+    if (opts.chain === 'BSC') {
+        try {
+            const helper = Helper3.connectByChain('BSC', opts.rpcUrl);
+            const info = await helper.getTokenInfo(token);
+            if (info) {
+                const tokenManager = info.tokenManager;
+                const versionNum = Number(info.version ?? 0);
+                const liquidityAdded = Boolean(info.liquidityAdded);
+                const isValid = tokenManager && tokenManager !== '0x0000000000000000000000000000000000000000' && (versionNum === 1 || versionNum === 2);
+                if (isValid) {
+                    // 若已添加流动性（已上 DEX），则继续外盘检测
+                    if (!liquidityAdded) {
+                        out.platform = 'FOUR';
+                        out.decimals = tokenDecimals;
+                        const reserveNative = info.funds !== undefined ? formatBalance(info.funds, shouldFormat) : undefined;
+                        const offerTokens = info.offers !== undefined ? formatBalance(info.offers, shouldFormat) : undefined;
+                        const lastPrice = info.lastPrice !== undefined ? formatBalance(info.lastPrice, shouldFormat) : undefined;
+                        out.four = { helper: ADDRESSES.BSC.TokenManagerHelper3, reserveNative, offerTokens, lastPrice };
+                        return out;
+                    }
+                    // liquidityAdded=true 表示已外盘，不在此返回
                 }
-                // liquidityAdded=true 表示已外盘，不在此返回
             }
         }
+        catch { }
     }
-    catch { }
     // 3) 外盘 V2：Pancake V2 getPair(token, WBNB/USDT) → getReserves（不立即返回，允许继续查 V3）
+    // ✅ 根据链动态获取代币地址
+    const chainTokens = getChainTokens();
     try {
         const { v2: v2FactoryAddr } = await resolveFactories();
         const v2Factory = new Contract(v2FactoryAddr, I_UNIV2_FACTORY_ABI, provider);
         const v2 = {};
-        // 独立查询 WBNB 交易对，避免一个失败影响另一个
+        // 独立查询原生包装代币交易对（BSC: WBNB, Monad: WMON），避免一个失败影响另一个
         try {
-            const v2PairWbnb = await v2Factory.getPair(token, TOKENS.BSC.WBNB);
+            const v2PairWbnb = await v2Factory.getPair(token, chainTokens.wrappedNative);
             if (v2PairWbnb && v2PairWbnb !== '0x0000000000000000000000000000000000000000') {
                 try {
                     const pair = new Contract(v2PairWbnb, I_UNIV2_PAIR_ABI, provider);
                     const [t0, t1] = await Promise.all([pair.token0(), pair.token1()]);
                     const [r0, r1] = await pair.getReserves();
                     const reserveToken = t0.toLowerCase() === token.toLowerCase() ? r0 : r1;
-                    const reserveWBNB = t0.toLowerCase() === TOKENS.BSC.WBNB.toLowerCase() ? r0 : r1;
+                    const reserveWBNB = t0.toLowerCase() === chainTokens.wrappedNative.toLowerCase() ? r0 : r1;
                     v2.wbnbPair = { address: v2PairWbnb, reserveToken: formatBalance(reserveToken, shouldFormat), reserveWBNB: formatBalance(reserveWBNB, shouldFormat) };
                 }
                 catch {
@@ -156,16 +197,16 @@ export async function inspectTokenLP(token, opts) {
             }
         }
         catch { }
-        // 独立查询 USDT 交易对
+        // 独立查询稳定币交易对（BSC: USDT, Monad: USDC）
         try {
-            const v2PairUsdt = await v2Factory.getPair(token, TOKENS.BSC.USDT);
+            const v2PairUsdt = await v2Factory.getPair(token, chainTokens.stableCoin);
             if (v2PairUsdt && v2PairUsdt !== '0x0000000000000000000000000000000000000000') {
                 try {
                     const pair = new Contract(v2PairUsdt, I_UNIV2_PAIR_ABI, provider);
                     const [t0, t1] = await Promise.all([pair.token0(), pair.token1()]);
                     const [r0, r1] = await pair.getReserves();
                     const reserveToken = t0.toLowerCase() === token.toLowerCase() ? r0 : r1;
-                    const reserveUSDT = t0.toLowerCase() === TOKENS.BSC.USDT.toLowerCase() ? r0 : r1;
+                    const reserveUSDT = t0.toLowerCase() === chainTokens.stableCoin.toLowerCase() ? r0 : r1;
                     v2.usdtPair = { address: v2PairUsdt, reserveToken: formatBalance(reserveToken, shouldFormat), reserveUSDT: formatBalance(reserveUSDT, shouldFormat) };
                 }
                 catch {
@@ -179,7 +220,10 @@ export async function inspectTokenLP(token, opts) {
         }
     }
     catch { }
-    // 4) 外盘 V3：Multicall 批量查询 pool 与余额
+    const v3BasePairs = [
+        { symbol: chainTokens.wrappedNativeSymbol, address: chainTokens.wrappedNative },
+        { symbol: chainTokens.stableCoinSymbol, address: chainTokens.stableCoin },
+    ];
     try {
         const fees = opts.v3FeeTiers ?? [100, 500, 2500, 3000, 10000];
         const { v3: v3FactoryAddr } = await resolveFactories();
@@ -189,20 +233,20 @@ export async function inspectTokenLP(token, opts) {
         if (opts.debug)
             console.log('[V3 Debug] Factory:', v3FactoryAddr, 'Fees:', fees);
         const poolCalls = [];
-        for (const base of ['WBNB', 'USDT']) {
-            const baseAddr = TOKENS.BSC[base];
+        for (const basePair of v3BasePairs) {
+            const baseAddr = basePair.address;
             for (const fee of fees) {
                 // V3 要求 token0 < token1 按地址字典序（必须全部用小写比较和赋值）
                 const tokenLower = token.toLowerCase();
                 const baseLower = baseAddr.toLowerCase();
                 const [token0, token1] = tokenLower < baseLower ? [tokenLower, baseLower] : [baseLower, tokenLower];
                 if (opts.debug)
-                    console.log(`[V3 Debug] ${base} fee=${fee}: getPool(${token0}, ${token1})`);
+                    console.log(`[V3 Debug] ${basePair.symbol} fee=${fee}: getPool(${token0}, ${token1})`);
                 // 只需一次调用，V3 getPool 要求严格顺序
                 poolCalls.push({
                     target: v3FactoryAddr,
                     callData: v3FactoryIface.encodeFunctionData('getPool', [token0, token1, fee]),
-                    base,
+                    base: basePair.symbol,
                     fee,
                     token0,
                     token1
@@ -226,7 +270,11 @@ export async function inspectTokenLP(token, opts) {
                     }
                     if (pool && pool.toLowerCase() !== '0x0000000000000000000000000000000000000000') {
                         // 直接添加，不去重（同一代币可能在不同 fee 档位都有池子）
-                        pools.push({ base: poolCalls[i].base, fee: poolCalls[i].fee, pool });
+                        // ✅ 根据 base symbol 获取对应的地址
+                        const baseAddress = poolCalls[i].base === chainTokens.wrappedNativeSymbol
+                            ? chainTokens.wrappedNative
+                            : chainTokens.stableCoin;
+                        pools.push({ base: poolCalls[i].base, fee: poolCalls[i].fee, pool, baseAddress });
                     }
                     else if (opts.debug) {
                         console.log(`  ⤷ Skipped (zero address)`);
@@ -244,7 +292,8 @@ export async function inspectTokenLP(token, opts) {
                 const calls = [];
                 for (const p of pools) {
                     calls.push({ target: token, callData: erc20Iface.encodeFunctionData('balanceOf', [p.pool]) });
-                    calls.push({ target: TOKENS.BSC[p.base], callData: erc20Iface.encodeFunctionData('balanceOf', [p.pool]) });
+                    // ✅ 使用动态的基础代币地址
+                    calls.push({ target: p.baseAddress, callData: erc20Iface.encodeFunctionData('balanceOf', [p.pool]) });
                 }
                 if (opts.debug)
                     console.log(`[V3 Debug] Querying balances for ${pools.length} pools (${calls.length} calls)...`);
@@ -293,11 +342,12 @@ export async function inspectTokenLP(token, opts) {
             const { v3: v3FactoryAddr } = await resolveFactories();
             const v3Factory = new Contract(v3FactoryAddr, I_UNIV3_FACTORY_ABI, provider);
             const erc20 = new Contract(token, I_ERC20_ABI, provider);
-            const wbnb = new Contract(TOKENS.BSC.WBNB, I_ERC20_ABI, provider);
-            const usdt = new Contract(TOKENS.BSC.USDT, I_ERC20_ABI, provider);
+            // ✅ 使用动态的基础代币地址
+            const wrappedNativeContract = new Contract(chainTokens.wrappedNative, I_ERC20_ABI, provider);
+            const stableCoinContract = new Contract(chainTokens.stableCoin, I_ERC20_ABI, provider);
             const v3Results = [];
-            for (const base of ['WBNB', 'USDT']) {
-                const baseAddr = TOKENS.BSC[base];
+            for (const basePair of v3BasePairs) {
+                const baseAddr = basePair.address;
                 for (const fee of fees) {
                     // V3 要求 token0 < token1 按地址字典序（必须全部用小写）
                     const tokenLower = token.toLowerCase();
@@ -314,11 +364,13 @@ export async function inspectTokenLP(token, opts) {
                             tb = await erc20.balanceOf(pool);
                         }
                         catch { }
+                        // ✅ 使用正确的合约对象
+                        const baseContract = basePair.symbol === chainTokens.wrappedNativeSymbol ? wrappedNativeContract : stableCoinContract;
                         try {
-                            bb = await (base === 'WBNB' ? wbnb : usdt).balanceOf(pool);
+                            bb = await baseContract.balanceOf(pool);
                         }
                         catch { }
-                        v3Results.push({ base, fee, pool, tokenBalance: formatBalance(tb, shouldFormat), baseBalance: formatBalance(bb, shouldFormat) });
+                        v3Results.push({ base: basePair.symbol, fee, pool, tokenBalance: formatBalance(tb, shouldFormat), baseBalance: formatBalance(bb, shouldFormat) });
                     }
                 }
             }

package/dist/utils/wallet.d.ts

@@ -38,6 +38,6 @@ export type MultiTokenBalancesResult = {
 };
 export declare function getTokenBalancesWithMulticall(rpcUrl: string, token: string, holders: string[]): Promise<MulticallResult[]>;
 export declare function getTokenBalancesWithMulticall(rpcUrl: string, multicall3: string, token: string, holders: string[]): Promise<MulticallResult[]>;
-export declare function getTokenBalancesWithMulticall(rpcUrl: string, chain: 'BSC' | 'BASE' | 'XLAYER' | 'MORPH' | 'ARBITRUM_ONE', tokenAddresses: string[], holders: string[]): Promise<MultiTokenBalancesResult[]>;
+export declare function getTokenBalancesWithMulticall(rpcUrl: string, chain: 'BSC' | 'BASE' | 'XLAYER' | 'MORPH' | 'ARBITRUM_ONE' | 'MONAD', tokenAddresses: string[], holders: string[]): Promise<MultiTokenBalancesResult[]>;
 export declare function getTokenBalancesWithMulticall(rpcUrl: string, tokenAddresses: string[], holders: string[]): Promise<MultiTokenBalancesResult[]>;
 export declare function getTokenBalancesWithMulticall(rpcUrl: string, chainId: number, tokenAddresses: string[], holders: string[]): Promise<MultiTokenBalancesResult[]>;

package/dist/utils/wallet.js

@@ -95,7 +95,8 @@ const MULTICALL3_BY_CHAIN = {
     8453: DEFAULT_MULTICALL3, // Base
     42161: DEFAULT_MULTICALL3, // Arbitrum One
     196: DEFAULT_MULTICALL3, // X Layer
-    2818: DEFAULT_MULTICALL3 // Morph
+    2818: DEFAULT_MULTICALL3, // Morph
+    143: DEFAULT_MULTICALL3, // ✅ Monad
 };
 export async function getTokenBalancesWithMulticall(rpcUrl, a, b, c) {
     const provider = new JsonRpcProvider(rpcUrl);

package/package.json

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

package/dist/flap/portal-bundle-merkle/encryption.d.ts

@@ -1,16 +0,0 @@
-/**
- * ECDH + AES-GCM 加密工具（浏览器兼容）
- * 用于将签名交易用服务器公钥加密
- */
-/**
- * 用服务器公钥加密签名交易（ECDH + AES-GCM）
- *
- * @param signedTransactions 签名后的交易数组
- * @param publicKeyBase64 服务器提供的公钥（Base64 格式）
- * @returns JSON 字符串 {e: 临时公钥, i: IV, d: 密文}
- */
-export declare function encryptWithPublicKey(signedTransactions: string[], publicKeyBase64: string): Promise<string>;
-/**
- * 验证公钥格式（Base64）
- */
-export declare function validatePublicKey(publicKeyBase64: string): boolean;

package/dist/flap/portal-bundle-merkle/encryption.js

@@ -1,146 +0,0 @@
-/**
- * ECDH + AES-GCM 加密工具（浏览器兼容）
- * 用于将签名交易用服务器公钥加密
- */
-/**
- * 获取全局 crypto 对象（最简单直接的方式）
- */
-function getCryptoAPI() {
-    // 尝试所有可能的全局对象，优先浏览器环境
-    const cryptoObj = (typeof window !== 'undefined' && window.crypto) ||
-        (typeof self !== 'undefined' && self.crypto) ||
-        (typeof global !== 'undefined' && global.crypto) ||
-        (typeof globalThis !== 'undefined' && globalThis.crypto);
-    if (!cryptoObj) {
-        const env = typeof window !== 'undefined' ? 'Browser' : 'Node.js';
-        const protocol = typeof location !== 'undefined' ? location.protocol : 'unknown';
-        throw new Error(`❌ Crypto API 不可用。环境: ${env}, 协议: ${protocol}. ` +
-            '请确保在 HTTPS 或 localhost 下运行');
-    }
-    return cryptoObj;
-}
-/**
- * 获取 SubtleCrypto（用于加密操作）
- */
-function getSubtleCrypto() {
-    const crypto = getCryptoAPI();
-    if (!crypto.subtle) {
-        const protocol = typeof location !== 'undefined' ? location.protocol : 'unknown';
-        const hostname = typeof location !== 'undefined' ? location.hostname : 'unknown';
-        throw new Error(`❌ SubtleCrypto API 不可用。协议: ${protocol}, 主机: ${hostname}. ` +
-            '请确保：1) 使用 HTTPS (或 localhost)；2) 浏览器支持 Web Crypto API；' +
-            '3) 不在无痕/隐私浏览模式下');
-    }
-    return crypto.subtle;
-}
-/**
- * Base64 转 ArrayBuffer（优先使用浏览器 API）
- */
-function base64ToArrayBuffer(base64) {
-    // 浏览器环境（优先）
-    if (typeof atob !== 'undefined') {
-        const binaryString = atob(base64);
-        const bytes = new Uint8Array(binaryString.length);
-        for (let i = 0; i < binaryString.length; i++) {
-            bytes[i] = binaryString.charCodeAt(i);
-        }
-        return bytes.buffer;
-    }
-    // Node.js 环境（fallback）
-    if (typeof Buffer !== 'undefined') {
-        return Buffer.from(base64, 'base64').buffer;
-    }
-    throw new Error('❌ Base64 解码不可用');
-}
-/**
- * ArrayBuffer 转 Base64（优先使用浏览器 API）
- */
-function arrayBufferToBase64(buffer) {
-    // 浏览器环境（优先）
-    if (typeof btoa !== 'undefined') {
-        const bytes = new Uint8Array(buffer);
-        let binary = '';
-        for (let i = 0; i < bytes.length; i++) {
-            binary += String.fromCharCode(bytes[i]);
-        }
-        return btoa(binary);
-    }
-    // Node.js 环境（fallback）
-    if (typeof Buffer !== 'undefined') {
-        return Buffer.from(buffer).toString('base64');
-    }
-    throw new Error('❌ Base64 编码不可用');
-}
-/**
- * 生成随机 Hex 字符串
- */
-function randomHex(length) {
-    const crypto = getCryptoAPI();
-    const array = new Uint8Array(length);
-    crypto.getRandomValues(array);
-    return Array.from(array)
-        .map(b => b.toString(16).padStart(2, '0'))
-        .join('');
-}
-/**
- * 用服务器公钥加密签名交易（ECDH + AES-GCM）
- *
- * @param signedTransactions 签名后的交易数组
- * @param publicKeyBase64 服务器提供的公钥（Base64 格式）
- * @returns JSON 字符串 {e: 临时公钥, i: IV, d: 密文}
- */
-export async function encryptWithPublicKey(signedTransactions, publicKeyBase64) {
-    try {
-        // 0. 获取 SubtleCrypto 和 Crypto API
-        const subtle = getSubtleCrypto();
-        const crypto = getCryptoAPI();
-        // 1. 准备数据
-        const payload = {
-            signedTransactions,
-            timestamp: Date.now(),
-            nonce: randomHex(8)
-        };
-        const plaintext = JSON.stringify(payload);
-        // 2. 生成临时 ECDH 密钥对
-        const ephemeralKeyPair = await subtle.generateKey({ name: 'ECDH', namedCurve: 'P-256' }, true, ['deriveKey']);
-        // 3. 导入服务器公钥
-        const publicKeyBuffer = base64ToArrayBuffer(publicKeyBase64);
-        const publicKey = await subtle.importKey('raw', publicKeyBuffer, { name: 'ECDH', namedCurve: 'P-256' }, false, []);
-        // 4. 派生共享密钥（AES-256）
-        const sharedKey = await subtle.deriveKey({ name: 'ECDH', public: publicKey }, ephemeralKeyPair.privateKey, { name: 'AES-GCM', length: 256 }, false, ['encrypt']);
-        // 5. AES-GCM 加密
-        const iv = crypto.getRandomValues(new Uint8Array(12));
-        const encrypted = await subtle.encrypt({ name: 'AES-GCM', iv }, sharedKey, new TextEncoder().encode(plaintext));
-        // 6. 导出临时公钥
-        const ephemeralPublicKeyRaw = await subtle.exportKey('raw', ephemeralKeyPair.publicKey);
-        // 7. 返回加密包（JSON 格式）
-        return JSON.stringify({
-            e: arrayBufferToBase64(ephemeralPublicKeyRaw), // 临时公钥
-            i: arrayBufferToBase64(iv.buffer), // IV
-            d: arrayBufferToBase64(encrypted) // 密文
-        });
-    }
-    catch (error) {
-        throw new Error(`加密失败: ${error?.message || String(error)}`);
-    }
-}
-/**
- * 验证公钥格式（Base64）
- */
-export function validatePublicKey(publicKeyBase64) {
-    try {
-        if (!publicKeyBase64)
-            return false;
-        // Base64 字符集验证
-        if (!/^[A-Za-z0-9+/=]+$/.test(publicKeyBase64))
-            return false;
-        // ECDH P-256 公钥固定长度 65 字节（未压缩）
-        // Base64 编码后约 88 字符
-        if (publicKeyBase64.length < 80 || publicKeyBase64.length > 100)
-            return false;
-        return true;
-    }
-    catch {
-        return false;
-    }
-}