four-flap-meme-sdk 2.0.0 → 2.1.0

package/dist/shared/clients 2/merkle.js

@@ -1,400 +0,0 @@
-/**
- * Merkle.io Bundle Service 客户端
- *
- * 提供基于 Merkle 的 MEV 保护和捆绑交易服务
- *
- * 官方文档: https://docs.merkle.io/
- *
- * 使用示例:
- * ```typescript
- * import { MerkleClient } from 'four-flap-meme-sdk';
- *
- * const merkle = new MerkleClient({
- *   apiKey: 'pk_mbs_...',
- *   chainId: 56
- * });
- *
- * const bundleHash = await merkle.sendBundle({
- *   transactions: [tx1, tx2, tx3],
- *   targetBlock: currentBlock + 2
- * });
- * ```
- */
-import { JsonRpcProvider, Transaction } from 'ethers';
-import { CHAINS } from '../constants/index.js';
-/**
- * Merkle 客户端
- */
-export class MerkleClient {
-    constructor(config) {
-        // ✅ 区块号缓存（减少 RPC 调用）
-        // 注意：TTL 设为 1 秒，确保区块号尽可能新鲜，减少 "Missed inclusion" 风险
-        this.blockNumberCache = null;
-        this.chainId = config.chainId;
-        this.chainName = config.chainId === CHAINS.BSC.chainId ? 'bsc' : 'ethereum';
-        // ✅ 修复：移除弃用的 mempool.merkle.io RPC，使用公共 RPC 作为默认值
-        // 优先使用用户自定义 RPC，否则使用官方公共 RPC
-        const defaultRpc = config.chainId === CHAINS.BSC.chainId
-            ? CHAINS.BSC.rpcUrls.backup // bsc-dataseed1
-            : CHAINS.ETHEREUM.rpcUrls.default;
-        const rpcUrl = config.customRpcUrl || defaultRpc;
-        this.provider = new JsonRpcProvider(rpcUrl, {
-            chainId: this.chainId,
-            name: this.chainName,
-        });
-    }
-    /**
-     * 获取 Provider
-     */
-    getProvider() {
-        return this.provider;
-    }
-    /**
-     * 获取当前区块号（带缓存，减少 RPC 调用）
-     * @param forceRefresh 是否强制刷新缓存
-     */
-    async getBlockNumber(forceRefresh = false) {
-        const now = Date.now();
-        // ✅ 检查缓存
-        if (!forceRefresh && this.blockNumberCache) {
-            const age = now - this.blockNumberCache.timestamp;
-            if (age < MerkleClient.BLOCK_CACHE_TTL_MS) {
-                // 缓存有效，直接返回（加 1 作为安全偏移）
-                return this.blockNumberCache.value;
-            }
-        }
-        // ✅ 缓存过期或强制刷新，查询 RPC
-        const blockNumber = await this.provider.getBlockNumber();
-        this.blockNumberCache = { value: blockNumber, timestamp: now };
-        return blockNumber;
-    }
-    /**
-     * 获取 Gas 价格信息
-     */
-    async getFeeData() {
-        return await this.provider.getFeeData();
-    }
-    /**
-     * 获取网络状态（用于 Bundle 参数优化）
-     */
-    async getNetworkStatus() {
-        const [currentBlock, feeData] = await Promise.all([
-            this.getBlockNumber(),
-            this.getFeeData()
-        ]);
-        // 动态获取 gas price，并计算建议的最小值
-        const baseGasPrice = feeData.gasPrice || feeData.maxFeePerGas || 3000000000n;
-        // 建议至少提高 80% 以确保交易被打包
-        const suggestedMinGasPrice = (baseGasPrice * 180n) / 100n;
-        // BSC 平均 3 秒，Ethereum 平均 12 秒
-        const avgBlockTime = this.chainId === CHAINS.BSC.chainId
-            ? CHAINS.BSC.blockTime / 1000
-            : CHAINS.ETHEREUM.blockTime / 1000;
-        return {
-            currentBlock,
-            gasPrice: baseGasPrice,
-            suggestedMinGasPrice,
-            avgBlockTime
-        };
-    }
-    /**
-     * 发送捆绑交易（底层方法）
-     *
-     * @param params Bundle 参数
-     * @returns Bundle Hash
-     */
-    async sendBundleRaw(params) {
-        // 验证输入
-        if (!params.txs || params.txs.length === 0) {
-            throw new Error('Bundle transactions cannot be empty');
-        }
-        if (!params.blockNumber) {
-            throw new Error('Target block number is required');
-        }
-        const bundleParams = {
-            txs: params.txs,
-            blockNumber: params.blockNumber,
-            minTimestamp: params.minTimestamp || 0,
-            maxTimestamp: params.maxTimestamp || 0,
-        };
-        try {
-            const result = await this.provider.send('eth_sendBundle', [bundleParams]);
-            // 规范化返回值
-            if (typeof result === 'string') {
-                return result;
-            }
-            // 如果是对象，尝试提取 bundleHash
-            if (result && typeof result === 'object') {
-                // Merkle 可能返回 { bundleHash: "0x..." }
-                if ('bundleHash' in result) {
-                    return String(result.bundleHash);
-                }
-                // 或者直接是哈希
-                if ('hash' in result) {
-                    return String(result.hash);
-                }
-                // 否则转为 JSON 字符串（但这不是理想情况）
-                return JSON.stringify(result);
-            }
-            throw new Error('Invalid bundle result format');
-        }
-        catch (error) {
-            // 增强错误信息
-            const errorMsg = error.message || String(error);
-            throw new Error(`Send bundle failed: ${errorMsg}`);
-        }
-    }
-    /**
-     * 发送捆绑交易（高级方法，带智能优化和重试）
-     *
-     * @param options 发送选项
-     * @returns Bundle 结果
-     */
-    async sendBundle(options) {
-        // 验证输入
-        if (!options.transactions || options.transactions.length === 0) {
-            throw new Error('Transactions array cannot be empty');
-        }
-        const minBlockOffset = options.minBlockOffset ?? 3; // 默认至少3个区块的窗口
-        const autoRetry = options.autoRetry ?? false;
-        const maxRetries = options.maxRetries ?? 2;
-        let attempt = 0;
-        let lastError = null;
-        while (attempt <= (autoRetry ? maxRetries : 0)) {
-            try {
-                // 实时获取当前区块（每次尝试都重新获取）
-                const currentBlock = await this.getBlockNumber();
-                // 确定目标区块
-                let targetBlock;
-                if (options.targetBlock) {
-                    targetBlock = options.targetBlock;
-                    // 检查目标区块是否已经过期
-                    if (targetBlock <= currentBlock) {
-                        if (autoRetry && attempt < maxRetries) {
-                            attempt++;
-                            await new Promise(resolve => setTimeout(resolve, 300)); // 短暂延迟
-                            continue;
-                        }
-                        throw new Error(`Target block ${targetBlock} has already passed (current block: ${currentBlock})`);
-                    }
-                }
-                else {
-                    // 动态计算：确保至少有 minBlockOffset 个区块的窗口
-                    const requestedOffset = options.blockOffset ?? 3;
-                    const actualOffset = Math.max(requestedOffset, minBlockOffset);
-                    targetBlock = currentBlock + actualOffset;
-                }
-                // 转换为十六进制
-                const targetBlockHex = '0x' + targetBlock.toString(16);
-                // 发送 Bundle
-                const bundleHash = await this.sendBundleRaw({
-                    txs: options.transactions,
-                    blockNumber: targetBlockHex,
-                    minTimestamp: options.minTimestamp,
-                    maxTimestamp: options.maxTimestamp,
-                });
-                // ✅ 优化：并行提取交易哈希（map 比 for 循环更高效）
-                const txHashes = options.transactions.map(rawTx => {
-                    try {
-                        return Transaction.from(rawTx).hash || '';
-                    }
-                    catch {
-                        return '';
-                    }
-                });
-                return {
-                    bundleHash,
-                    txHashes,
-                    targetBlock,
-                    txCount: options.transactions.length,
-                };
-            }
-            catch (error) {
-                lastError = error;
-                // 如果启用了重试且还有重试次数
-                if (autoRetry && attempt < maxRetries) {
-                    attempt++;
-                    // 等待一个区块时间再重试
-                    const blockTime = this.chainId === CHAINS.BSC.chainId
-                        ? CHAINS.BSC.blockTime
-                        : CHAINS.ETHEREUM.blockTime;
-                    await new Promise(resolve => setTimeout(resolve, blockTime));
-                    continue;
-                }
-                // 没有重试或已达最大重试次数
-                throw error;
-            }
-        }
-        // 如果执行到这里，说明所有重试都失败了
-        throw lastError || new Error('Bundle submission failed after all retries');
-    }
-    /**
-     * 等待 Bundle 中的交易确认
-     *
-     * @param txHashes 交易哈希列表
-     * @param confirmations 确认数（默认 1）
-     * @param timeout 超时时间（毫秒，默认 120000）
-     * @returns 交易结果列表
-     */
-    async waitForBundleConfirmation(txHashes, confirmations = 1, timeout = 120000) {
-        const promises = txHashes.map(async (hash, index) => {
-            try {
-                const receipt = await this.provider.waitForTransaction(hash, confirmations, timeout);
-                if (!receipt) {
-                    return {
-                        index,
-                        hash,
-                        success: false,
-                        error: 'Transaction not found',
-                    };
-                }
-                let gasCost;
-                if (receipt.gasUsed && receipt.gasPrice) {
-                    // 使用 BigInt 避免精度丢失
-                    try {
-                        const costWei = receipt.gasUsed * receipt.gasPrice;
-                        // 转换为 ETH/BNB（保持精度）
-                        const costEth = Number(costWei) / 1e18;
-                        gasCost = costEth.toFixed(8); // 增加精度到 8 位小数
-                    }
-                    catch (error) {
-                        // 如果计算溢出，使用字符串处理
-                        const costWei = receipt.gasUsed * receipt.gasPrice;
-                        gasCost = (Number(costWei / 1000000000n) / 1e9).toFixed(8);
-                    }
-                }
-                return {
-                    index,
-                    hash,
-                    success: receipt.status === 1,
-                    blockNumber: receipt.blockNumber,
-                    gasUsed: receipt.gasUsed.toString(),
-                    effectiveGasPrice: receipt.gasPrice?.toString(),
-                    gasCost,
-                };
-            }
-            catch (error) {
-                return {
-                    index,
-                    hash,
-                    success: false,
-                    error: error.message,
-                };
-            }
-        });
-        return await Promise.all(promises);
-    }
-    /**
-     * 准备并签名交易（辅助方法）
-     *
-     * @param wallet 钱包
-     * @param transactions 交易列表
-     * @param options 可选参数
-     * @returns 已签名的交易数组
-     */
-    async signTransactions(wallet, transactions, options) {
-        // 验证输入
-        if (!transactions || transactions.length === 0) {
-            throw new Error('Transactions array cannot be empty');
-        }
-        // 获取起始 Nonce（使用 pending 确保包含待处理交易）
-        let nonce = options?.startNonce;
-        if (nonce === undefined) {
-            nonce = await this.provider.getTransactionCount(wallet.address, 'pending');
-        }
-        // 获取 Gas Price
-        let gasPrice = options?.gasPrice;
-        if (!gasPrice) {
-            const feeData = await this.provider.getFeeData();
-            // 动态获取基础 gas price，增加容错
-            const baseGasPrice = feeData.gasPrice || feeData.maxFeePerGas || 3000000000n;
-            const multiplier = options?.gasPriceMultiplier || 50;
-            gasPrice = (baseGasPrice * BigInt(100 + multiplier)) / 100n;
-        }
-        // 签名所有交易（避免直接修改 nonce）
-        const signedTxs = [];
-        for (let i = 0; i < transactions.length; i++) {
-            const currentNonce = nonce + i;
-            const fullTx = {
-                ...transactions[i],
-                nonce: currentNonce,
-                gasPrice,
-                chainId: this.chainId,
-            };
-            const signedTx = await wallet.signTransaction(fullTx);
-            signedTxs.push(signedTx);
-        }
-        return signedTxs;
-    }
-    /**
-     * 检查交易是否已包含在区块中
-     *
-     * @param txHash 交易哈希
-     * @returns 是否已包含
-     */
-    async isTransactionIncluded(txHash) {
-        try {
-            const receipt = await this.provider.getTransactionReceipt(txHash);
-            return receipt !== null && receipt.blockNumber !== null;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * 等待达到目标区块
-     *
-     * @param targetBlock 目标区块号
-     * @param maxAttempts 最大尝试次数（默认 10）
-     * @param intervalMs 检查间隔（毫秒，默认 1000）
-     * @returns 是否达到目标区块
-     */
-    async waitForBlock(targetBlock, maxAttempts = 10, intervalMs = 1000) {
-        let attempts = 0;
-        let lastError = null;
-        while (attempts < maxAttempts) {
-            try {
-                const currentBlock = await this.getBlockNumber();
-                // 已达到或超过目标区块
-                if (currentBlock >= targetBlock) {
-                    return true;
-                }
-                // 检查是否已经错过目标区块（超过太多）
-                // 修复：应该是 currentBlock > targetBlock，而不是 targetBlock + 5
-                if (currentBlock > targetBlock) {
-                    // 已经错过目标区块
-                    return false;
-                }
-            }
-            catch (error) {
-                lastError = error;
-                // 继续重试
-            }
-            // 等待下一次检查
-            await new Promise(resolve => setTimeout(resolve, intervalMs));
-            attempts++;
-        }
-        // 达到最大尝试次数
-        if (lastError) {
-        }
-        return false;
-    }
-    /**
-     * 获取当前 Provider 的统计信息（用于调试）
-     */
-    getProviderInfo() {
-        return {
-            chainId: this.chainId,
-            chainName: this.chainName,
-            // @ts-ignore - 访问私有属性用于调试
-            rpcUrl: this.provider._getConnection?.().url || 'unknown',
-        };
-    }
-}
-MerkleClient.BLOCK_CACHE_TTL_MS = 1000; // 1秒缓存（BSC 约 3 秒出块，ETH 约 12 秒）
-/**
- * 创建 Merkle 客户端的便捷函数
- */
-export function createMerkleClient(apiKey, chainId = 56) {
-    return new MerkleClient({ apiKey, chainId });
-}

package/dist/shared/flap/__tests__/curve.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/shared/flap/__tests__/curve.test.js

@@ -1,85 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { CDPV2 } from '../curve.js';
-describe('CDPV2', () => {
-    describe('getCurve', () => {
-        it('creates curve with default h and k when only r is provided', () => {
-            const curve = CDPV2.getCurve(0.1);
-            expect(curve.r).toBe(0.1);
-            expect(curve.h).toBe(0);
-            expect(curve.k).toBe(1e9 * 0.1);
-        });
-        it('creates curve with explicit h and k', () => {
-            const curve = CDPV2.getCurve(0.1, 1000, 500000);
-            expect(curve.r).toBe(0.1);
-            expect(curve.h).toBe(1000);
-            expect(curve.k).toBe(500000);
-        });
-    });
-    describe('estimateSupply', () => {
-        it('returns 0 for empty reserve', () => {
-            const curve = CDPV2.getCurve(0.1);
-            expect(curve.estimateSupply('0').toString()).toBe('0.0');
-        });
-        it('returns 0 for falsy reserve', () => {
-            const curve = CDPV2.getCurve(0.1);
-            expect(curve.estimateSupply('').toString()).toBe('0.0');
-        });
-        it('calculates supply correctly for given reserve', () => {
-            const curve = CDPV2.getCurve(0.1);
-            const supply = curve.estimateSupply('1000000');
-            expect(supply.toUnsafeFloat()).toBeGreaterThan(0);
-            expect(supply.toUnsafeFloat()).toBeLessThan(1_000_000_000);
-        });
-    });
-    describe('estimateReserve', () => {
-        it('returns 0 for empty amount', () => {
-            const curve = CDPV2.getCurve(0.1);
-            expect(curve.estimateReserve('0').toString()).toBe('0.0');
-        });
-        it('returns 0 for falsy amount', () => {
-            const curve = CDPV2.getCurve(0.1);
-            expect(curve.estimateReserve('').toString()).toBe('0.0');
-        });
-        it('calculates reserve inversely proportional to supply', () => {
-            const curve = CDPV2.getCurve(0.1);
-            const reserve = curve.estimateReserve('500000000');
-            expect(reserve.toUnsafeFloat()).toBeGreaterThan(0);
-        });
-        it('supply and reserve are mutually consistent', () => {
-            const curve = CDPV2.getCurve(0.1);
-            const initialReserve = '1000000';
-            const supply = curve.estimateSupply(initialReserve);
-            const reserveBack = curve.estimateReserve(supply.toString());
-            // Allow small rounding differences
-            const diff = Math.abs(reserveBack.toUnsafeFloat() - 1_000_000);
-            expect(diff).toBeLessThan(1);
-        });
-    });
-    describe('price', () => {
-        it('returns positive price for valid supply', () => {
-            const curve = CDPV2.getCurve(0.1);
-            const p = curve.price('500000000');
-            expect(p.toUnsafeFloat()).toBeGreaterThan(0);
-        });
-        it('price increases as supply increases (bonding curve)', () => {
-            const curve = CDPV2.getCurve(0.1);
-            const priceLow = curve.price('100000000');
-            const priceHigh = curve.price('500000000');
-            expect(priceHigh.toUnsafeFloat()).toBeGreaterThan(priceLow.toUnsafeFloat());
-        });
-    });
-    describe('fdv', () => {
-        it('calculates FDV as price * 1B', () => {
-            const curve = CDPV2.getCurve(0.1);
-            const supply = '500000000';
-            const p = curve.price(supply);
-            const f = curve.fdv(supply);
-            expect(f.toUnsafeFloat()).toBeCloseTo(p.toUnsafeFloat() * 1_000_000_000, -3);
-        });
-    });
-    describe('defaultDexSupplyThreshold', () => {
-        it('returns 800M', () => {
-            expect(CDPV2.defaultDexSupplyThreshold().toString()).toBe('800000000.0');
-        });
-    });
-});

package/dist/shared/flap/portal/index.d.ts

@@ -1,12 +0,0 @@
-/**
- * Flap Portal 模块
- *
- * 拆分自 portal.ts。包括：
- * - types.ts — 枚举、类型、工具函数
- * - portal.ts — FlapPortal（只读操作）
- * - writer.ts — FlapPortalWriter（读写操作）
- */
-export type { FlapChain, PortalConfig, TokenStateV2, TokenStateV3, TokenStateV4, TokenStateV5, TokenStateV7, QuoteExactInputParams, ExactInputParams, ExactInputV3Params, NewTokenV3Params, NewTokenV4Params, NewTokenV5Params, TaxDistributionConfig, TokenStatus, TokenVersion, DexThreshType, MigratorType, V3LPFeeProfile, DEXId, } from './types.js';
-export { FlapPortal } from './portal.js';
-export { FlapPortalWriter } from './writer.js';
-export { lpFeeProfileToV3Fee, validateTaxDistribution } from './types.js';

package/dist/shared/flap/portal/index.js

@@ -1,11 +0,0 @@
-/**
- * Flap Portal 模块
- *
- * 拆分自 portal.ts。包括：
- * - types.ts — 枚举、类型、工具函数
- * - portal.ts — FlapPortal（只读操作）
- * - writer.ts — FlapPortalWriter（读写操作）
- */
-export { FlapPortal } from './portal.js';
-export { FlapPortalWriter } from './writer.js';
-export { lpFeeProfileToV3Fee, validateTaxDistribution } from './types.js';

package/dist/shared/flap/portal/portal.d.ts

@@ -1,47 +0,0 @@
-import type { PortalConfig, TokenStateV2, TokenStateV3, TokenStateV4, TokenStateV5, TokenStateV7, QuoteExactInputParams } from './types.js';
-import { Contract } from 'ethers';
-export declare class FlapPortal {
-    private rpcUrl;
-    protected portal: string;
-    protected contract: Contract;
-    private buyFeeRate;
-    private sellFeeRate;
-    constructor(cfg: PortalConfig);
-    getTokenV2(token: string): Promise<TokenStateV2>;
-    getTokenV3(token: string): Promise<TokenStateV3>;
-    getTokenV4(token: string): Promise<TokenStateV4>;
-    getTokenV5(token: string): Promise<TokenStateV5>;
-    /**
-     * 获取代币状态 V7（包含毕业相关信息）
-     * 注意：仅部分链支持 V7（如 XLayer v5.7+），不支持的链会 revert
-     */
-    getTokenV7(token: string): Promise<TokenStateV7>;
-    /**
-     * 计算距离毕业还需多少 OKB/ETH（含手续费）
-     * @param state TokenStateV5 或 TokenStateV7
-     * @returns 毕业相关信息
-     */
-    computeRemainingToGraduation(state: TokenStateV5 | TokenStateV7): {
-        remainingOkb: string;
-        graduationReserve: string;
-        currentReserve: string;
-        isGraduated: boolean;
-        progressPercent: string;
-    };
-    computePriceAndProgress(state: TokenStateV5): {
-        price: string;
-        progress: string;
-    };
-    quoteBuy(state: TokenStateV5, inputEth: string): string;
-    quoteSell(state: TokenStateV5, inputToken: string): string;
-    previewBuy(token: string, ethAmount: bigint): Promise<bigint>;
-    previewSell(token: string, tokenAmount: bigint): Promise<bigint>;
-    quoteExactInput(params: QuoteExactInputParams): Promise<bigint>;
-    getFeeRate(): Promise<{
-        buyFeeRate: bigint;
-        sellFeeRate: bigint;
-    }>;
-    nonce(): Promise<bigint>;
-    version(): Promise<string>;
-    getLocks(token: string): Promise<bigint[]>;
-}