four-flap-meme-sdk 2.0.0 → 2.2.0

package/dist/shared/clients 2/four.d.ts

@@ -1,132 +0,0 @@
-export type NetworkCode = 'BSC';
-export type FourConfig = {
-    /**
-     * Four.meme API 基础 URL
-     *
-     * 默认使用 Cloudflare Workers 代理（已配置 CORS，可在浏览器中直接使用）
-     * 如需自定义，可传入自己的代理地址
-     */
-    baseUrl?: string;
-    /**
-     * 图片上传备用代理 URL 列表
-     *
-     * 当主 baseUrl 触发 IP 限流（code -1038）时，自动依次尝试备用端点。
-     * 每个 URL 格式同 baseUrl，例如 'https://bscfourapi2.emit.tools'
-     */
-    uploadFallbackUrls?: string[];
-};
-export type GenerateNonceReq = {
-    accountAddress: string;
-    verifyType: 'LOGIN';
-    networkCode: NetworkCode;
-};
-export type LoginReq = {
-    region: 'WEB';
-    langType: 'EN' | 'ZH';
-    loginIp?: string;
-    inviteCode?: string;
-    verifyInfo: {
-        address: string;
-        networkCode: NetworkCode;
-        signature: string;
-        verifyType: 'LOGIN';
-    };
-    walletName: 'MetaMask' | string;
-};
-/**
- * Four.meme 税币配置参数
- * - feeRate: 交易费率（固定选项：1, 3, 5, 10，代表 1%, 3%, 5%, 10%）
- * - burnRate: 销毁比例（百分比，如 20 = 20%）
- * - divideRate: 分红比例（百分比，如 30 = 30%）
- * - liquidityRate: 流动性池比例（百分比，如 40 = 40%）
- * - recipientRate: 创始人/接收者比例（百分比，如 10 = 10%）
- * - recipientAddress: 接收者地址（不使用时传空字符串 ""）
- * - minSharing: 最低持仓分红门槛（ether 单位，须满足 d × 10^n, n≥5, 1≤d≤9）
- *
- * 约束：burnRate + divideRate + liquidityRate + recipientRate = 100
- */
-export type FourTokenTaxInfo = {
-    feeRate: 1 | 3 | 5 | 10;
-    burnRate: number;
-    divideRate: number;
-    liquidityRate: number;
-    recipientRate: number;
-    recipientAddress: string;
-    minSharing: number;
-};
-export type CreateTokenReq = {
-    name: string;
-    shortName: string;
-    desc: string;
-    imgUrl: string;
-    launchTime: number;
-    label: 'Meme' | 'AI' | 'Defi' | 'Games' | 'Infra' | 'De-Sci' | 'Social' | 'Depin' | 'Charity' | 'Others';
-    webUrl?: string;
-    twitterUrl?: string;
-    telegramUrl?: string;
-    preSale: string;
-    onlyMPC?: boolean;
-    /**
-     * AntiSniperFeeMode（开盘高税模式）
-     * - true: 启用动态手续费系统（开盘时高税，逐区块自动降低）
-     * - false: 不启用（默认）
-     */
-    feePlan?: boolean;
-    /**
-     * 税币配置（Tax Token）
-     * - 提供此字段时创建税币（creatorType = 5）
-     * - 不提供或为 undefined 时创建普通代币
-     */
-    tokenTaxInfo?: FourTokenTaxInfo;
-    lpTradingFee: 0.0025;
-    symbol: 'BNB';
-    totalSupply: 1000000000;
-    raisedAmount: 24;
-    saleRate: 0.8;
-    reserveRate: 0;
-    funGroup: false;
-    clickFun: false;
-};
-export type CreateTokenResp = {
-    createArg: string;
-    signature: string;
-    tokenAddr?: string;
-    address?: string;
-    token?: string;
-    [key: string]: any;
-};
-export declare class FourClient {
-    private baseUrl;
-    private uploadUrls;
-    constructor(cfg?: FourConfig);
-    generateNonce(req: GenerateNonceReq): Promise<string>;
-    loginDex(body: LoginReq): Promise<string>;
-    /**
-     * 上传图片到 Four.meme
-     *
-     * 优化策略：
-     * 1. 图片内容哈希缓存 —— 相同图片不重复上传，直接返回缓存 URL
-     * 2. 多端点轮换 —— 当某个代理 IP 触发限流（-1038）时自动切到下一个端点
-     */
-    uploadImage(accessToken: string, file: Blob, filename?: string): Promise<string>;
-    /**
-     * 执行单次上传请求
-     */
-    private doUpload;
-    /**
-     * 判断是否为 IP 限流错误（code: -1038）
-     */
-    private isRateLimitError;
-    /**
-     * 判断是否为 CORS 或网络错误
-     * 浏览器直连官方 API 时常见（fetch 会抛出 TypeError: Failed to fetch）
-     */
-    private isCorsOrNetworkError;
-    private getFilenameFromBlob;
-    createToken(accessToken: string, req: CreateTokenReq): Promise<CreateTokenResp>;
-    getPublicConfig(): Promise<any>;
-    getTokenByAddress(address: string, accessToken?: string): Promise<any>;
-    getTokensByAddresses(addresses: string[], accessToken?: string): Promise<any[]>;
-    getTokenById(id: string | number, accessToken?: string): Promise<any>;
-}
-export declare function buildLoginMessage(nonce: string): string;

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

@@ -1,281 +0,0 @@
-// ============================================================================
-// 图片上传缓存（按内容哈希去重，同一张图片只上传一次）
-// ✅ 使用 localStorage 持久化，刷新页面 / 重启浏览器后缓存仍然有效
-// ============================================================================
-const UPLOAD_CACHE_KEY = '__four_upload_cache__';
-const UPLOAD_CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000; // 7 天过期
-/** 内存缓存（从 localStorage 懒加载） */
-let _memCache = null;
-/** 加载持久化缓存到内存 */
-function loadCache() {
-    if (_memCache)
-        return _memCache;
-    _memCache = new Map();
-    try {
-        if (typeof localStorage === 'undefined')
-            return _memCache;
-        const raw = localStorage.getItem(UPLOAD_CACHE_KEY);
-        if (raw) {
-            const entries = JSON.parse(raw);
-            const now = Date.now();
-            for (const [hash, entry] of Object.entries(entries)) {
-                // 跳过过期条目
-                if (now - entry.ts < UPLOAD_CACHE_MAX_AGE_MS) {
-                    _memCache.set(hash, entry);
-                }
-            }
-        }
-    }
-    catch {
-        // localStorage 不可用或数据损坏，忽略
-    }
-    return _memCache;
-}
-/** 保存内存缓存到 localStorage */
-function saveCache() {
-    try {
-        if (typeof localStorage === 'undefined')
-            return;
-        const cache = loadCache();
-        const obj = {};
-        cache.forEach((v, k) => { obj[k] = v; });
-        localStorage.setItem(UPLOAD_CACHE_KEY, JSON.stringify(obj));
-    }
-    catch {
-        // localStorage 写满或不可用，忽略
-    }
-}
-/** 从缓存获取 URL */
-function getCachedUrl(hash) {
-    const cache = loadCache();
-    const entry = cache.get(hash);
-    if (!entry)
-        return null;
-    if (Date.now() - entry.ts > UPLOAD_CACHE_MAX_AGE_MS) {
-        cache.delete(hash);
-        saveCache();
-        return null;
-    }
-    return entry.url;
-}
-/** 写入缓存 */
-function setCachedUrl(hash, url) {
-    const cache = loadCache();
-    cache.set(hash, { url, ts: Date.now() });
-    saveCache();
-}
-/**
- * 计算 Blob 的 SHA-256 哈希（十六进制）
- * 用于图片去重，避免重复上传消耗 IP 配额
- */
-async function hashBlob(blob) {
-    const buffer = await blob.arrayBuffer();
-    const hashBuffer = await crypto.subtle.digest('SHA-256', buffer);
-    const hashArray = Array.from(new Uint8Array(hashBuffer));
-    return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
-}
-/** IP 限流错误码 */
-const RATE_LIMIT_CODE = -1038;
-/**
- * Four.meme 官方 API 地址（作为内置备用端点）
- *
- * - 在 Node.js/服务端环境中：无 CORS 限制，直连走用户自己的 IP，不消耗 Worker 配额
- * - 在浏览器环境中：可能被 CORS 拦截，但作为最后的 fallback 仍值得尝试
- */
-const FOUR_MEME_OFFICIAL_API = 'https://four.meme/meme-api';
-export class FourClient {
-    constructor(cfg) {
-        // 默认使用 Cloudflare Workers 代理，已配置 CORS，浏览器可直接使用
-        this.baseUrl = cfg?.baseUrl || 'https://bscfourapi.emit.tools';
-        // 上传端点列表：主 URL + 用户自定义备用 URL + 官方 API（兜底）
-        const fallbacks = cfg?.uploadFallbackUrls || [];
-        this.uploadUrls = [
-            this.baseUrl,
-            ...fallbacks,
-            // ✅ 官方 API 始终作为最后兜底（Node.js 环境无 CORS 限制，走用户自己 IP）
-            FOUR_MEME_OFFICIAL_API,
-        ];
-        // 去重（如果用户 baseUrl 就是官方地址，避免重复请求）
-        this.uploadUrls = [...new Set(this.uploadUrls)];
-    }
-    async generateNonce(req) {
-        const r = await fetch(`${this.baseUrl}/v1/private/user/nonce/generate`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(req),
-        });
-        const j = await r.json();
-        // code 可能是字符串 '0' 或数字 0
-        if (j.code !== '0' && j.code !== 0) {
-            throw new Error(`generateNonce failed: ${JSON.stringify(j)}`);
-        }
-        return j.data;
-    }
-    async loginDex(body) {
-        const r = await fetch(`${this.baseUrl}/v1/private/user/login/dex`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(body),
-        });
-        const j = await r.json();
-        if (j.code !== '0' && j.code !== 0) {
-            throw new Error(`login failed: ${JSON.stringify(j)}`);
-        }
-        return j.data; // access_token
-    }
-    /**
-     * 上传图片到 Four.meme
-     *
-     * 优化策略：
-     * 1. 图片内容哈希缓存 —— 相同图片不重复上传，直接返回缓存 URL
-     * 2. 多端点轮换 —— 当某个代理 IP 触发限流（-1038）时自动切到下一个端点
-     */
-    async uploadImage(accessToken, file, filename) {
-        // ✅ 先查缓存（localStorage 持久化）：相同图片直接返回，不消耗上传配额
-        const hash = await hashBlob(file);
-        const cached = getCachedUrl(hash);
-        if (cached) {
-            console.log(`[FourClient] 图片命中缓存，跳过上传 (hash: ${hash.slice(0, 12)}...)`);
-            return cached;
-        }
-        const finalFilename = filename || this.getFilenameFromBlob(file);
-        let lastError = null;
-        // ✅ 依次尝试所有上传端点（代理 → 自定义备用 → 官方直连兜底）
-        for (let i = 0; i < this.uploadUrls.length; i++) {
-            const baseUrl = this.uploadUrls[i];
-            const isOfficial = baseUrl === FOUR_MEME_OFFICIAL_API;
-            try {
-                const imgUrl = await this.doUpload(baseUrl, accessToken, file, finalFilename);
-                // 上传成功，写入持久化缓存（localStorage）
-                setCachedUrl(hash, imgUrl);
-                if (i > 0) {
-                    console.log(`[FourClient] 使用${isOfficial ? '官方直连' : '备用'}端点上传成功: ${baseUrl}`);
-                }
-                return imgUrl;
-            }
-            catch (e) {
-                lastError = e;
-                const canRetry = i < this.uploadUrls.length - 1;
-                if (this.isRateLimitError(e) && canRetry) {
-                    // IP 限流 → 切下一个端点
-                    const nextUrl = this.uploadUrls[i + 1];
-                    const nextLabel = nextUrl === FOUR_MEME_OFFICIAL_API ? '官方直连' : `备用端点 #${i + 2}`;
-                    console.warn(`[FourClient] 端点 ${baseUrl} 触发 IP 限流(100次/天)，切换到${nextLabel}...`);
-                    continue;
-                }
-                if (this.isCorsOrNetworkError(e) && canRetry) {
-                    // CORS/网络错误（常见于浏览器直连官方 API）→ 跳过，继续尝试下一个
-                    console.warn(`[FourClient] 端点 ${baseUrl} 请求失败(${isOfficial ? 'CORS限制' : '网络错误'})，跳过`);
-                    continue;
-                }
-                // 无法重试，跳出
-                break;
-            }
-        }
-        // 所有端点都失败
-        const isRateLimit = lastError && this.isRateLimitError(lastError);
-        if (isRateLimit) {
-            throw new Error(`图片上传失败：所有端点均触发 IP 限流(每IP每天100次)。` +
-                `请等待次日重置，或在 FourConfig.uploadFallbackUrls 中添加不同 IP 的备用代理。` +
-                `\n原始错误: ${lastError.message}`);
-        }
-        throw lastError || new Error('upload failed: all endpoints exhausted');
-    }
-    /**
-     * 执行单次上传请求
-     */
-    async doUpload(baseUrl, accessToken, file, filename) {
-        const form = new FormData();
-        form.append('file', file, filename);
-        const r = await fetch(`${baseUrl}/v1/private/token/upload`, {
-            method: 'POST',
-            headers: { 'meme-web-access': accessToken },
-            body: form,
-        });
-        const j = await r.json();
-        if (j.code !== '0' && j.code !== 0) {
-            const err = new Error(`upload failed: ${JSON.stringify(j)}`);
-            err.apiCode = typeof j.code === 'string' ? parseInt(j.code, 10) : j.code;
-            throw err;
-        }
-        return j.data; // imgUrl
-    }
-    /**
-     * 判断是否为 IP 限流错误（code: -1038）
-     */
-    isRateLimitError(e) {
-        if (e?.apiCode === RATE_LIMIT_CODE)
-            return true;
-        // 兼容：从 message 中检测
-        if (typeof e?.message === 'string' && e.message.includes('-1038'))
-            return true;
-        return false;
-    }
-    /**
-     * 判断是否为 CORS 或网络错误
-     * 浏览器直连官方 API 时常见（fetch 会抛出 TypeError: Failed to fetch）
-     */
-    isCorsOrNetworkError(e) {
-        if (e instanceof TypeError)
-            return true; // fetch CORS / network failure
-        const msg = e?.message?.toLowerCase?.() || '';
-        return msg.includes('failed to fetch') || msg.includes('network') || msg.includes('cors');
-    }
-    getFilenameFromBlob(blob) {
-        const mimeToExt = {
-            'image/jpeg': 'jpg',
-            'image/jpg': 'jpg',
-            'image/png': 'png',
-            'image/gif': 'gif',
-            'image/bmp': 'bmp',
-            'image/webp': 'webp',
-        };
-        const ext = mimeToExt[blob.type] || 'png';
-        return `image-${Date.now()}.${ext}`;
-    }
-    async createToken(accessToken, req) {
-        const r = await fetch(`${this.baseUrl}/v1/private/token/create`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json', 'meme-web-access': accessToken },
-            body: JSON.stringify(req),
-        });
-        const j = await r.json();
-        if (j.code !== '0' && j.code !== 0) {
-            throw new Error(`createToken failed: ${JSON.stringify(j)}`);
-        }
-        return j.data;
-    }
-    async getPublicConfig() {
-        const r = await fetch(`${this.baseUrl}/v1/public/config`);
-        return await r.json();
-    }
-    async getTokenByAddress(address, accessToken) {
-        const r = await fetch(`${this.baseUrl}/v1/private/token/get?address=${address}`, {
-            headers: accessToken ? { 'meme-web-access': accessToken } : undefined,
-        });
-        const j = await r.json();
-        if (j.code && j.code !== '0' && j.code !== 0) {
-            throw new Error(`getTokenByAddress failed: ${JSON.stringify(j)}`);
-        }
-        return j.data ?? j;
-    }
-    async getTokensByAddresses(addresses, accessToken) {
-        if (!Array.isArray(addresses) || addresses.length === 0)
-            return [];
-        const tasks = addresses.map((addr) => this.getTokenByAddress(addr, accessToken).catch((e) => ({ address: addr, error: String(e) })));
-        return await Promise.all(tasks);
-    }
-    async getTokenById(id, accessToken) {
-        const r = await fetch(`${this.baseUrl}/v1/private/token/getById?id=${id}`, {
-            headers: accessToken ? { 'meme-web-access': accessToken } : undefined,
-        });
-        const j = await r.json();
-        if (j.code && j.code !== '0' && j.code !== 0) {
-            throw new Error(`getTokenById failed: ${JSON.stringify(j)}`);
-        }
-        return j.data ?? j;
-    }
-}
-export function buildLoginMessage(nonce) {
-    return `You are sign in Meme ${nonce}`;
-}

package/dist/shared/clients 2/merkle.d.ts

@@ -1,210 +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, Wallet, TransactionLike } from 'ethers';
-/**
- * Merkle 客户端配置
- */
-export interface MerkleConfig {
-    /** Merkle API Key (例如: pk_mbs_...) */
-    apiKey: string;
-    /** 链 ID: 56=BSC, 1=Ethereum */
-    chainId: 56 | 1;
-    /** 自定义 RPC URL（可选，默认使用 Merkle 官方 RPC） */
-    customRpcUrl?: string;
-}
-/**
- * Bundle 参数
- */
-export interface BundleParams {
-    /** 已签名的交易数组（原始交易字符串） */
-    txs: string[];
-    /** 目标区块号（十六进制字符串，例如: "0x123abc"） */
-    blockNumber: string;
-    /** 最小时间戳（可选，0 表示不限制） */
-    minTimestamp?: number;
-    /** 最大时间戳（可选，0 表示不限制） */
-    maxTimestamp?: number;
-}
-/**
- * 网络状态信息
- */
-export interface NetworkStatus {
-    /** 当前区块号 */
-    currentBlock: number;
-    /** 当前 Gas Price (wei) */
-    gasPrice: bigint;
-    /** 建议的最小 Gas Price (wei) */
-    suggestedMinGasPrice: bigint;
-    /** 平均出块时间（秒） */
-    avgBlockTime: number;
-}
-/**
- * 发送 Bundle 的选项
- */
-export interface SendBundleOptions {
-    /** 已签名的交易数组 */
-    transactions: string[];
-    /** 目标区块号（十进制数字，会自动转换为十六进制） */
-    targetBlock?: number;
-    /** 最小时间戳 */
-    minTimestamp?: number;
-    /** 最大时间戳 */
-    maxTimestamp?: number;
-    /** 如果不指定 targetBlock，则使用当前区块 + offset（默认3） */
-    blockOffset?: number;
-    /** 最小区块偏移量，用于确保足够的提交时间窗口（默认3） */
-    minBlockOffset?: number;
-    /** 是否启用自动重试（默认false） */
-    autoRetry?: boolean;
-    /** 最大重试次数（默认2） */
-    maxRetries?: number;
-}
-/**
- * Bundle 发送结果
- */
-export interface BundleResult {
-    /** Bundle Hash */
-    bundleHash: string;
-    /** 交易哈希列表 */
-    txHashes: string[];
-    /** 目标区块号 */
-    targetBlock: number;
-    /** 交易数量 */
-    txCount: number;
-}
-/**
- * 交易确认结果
- */
-export interface TransactionResult {
-    /** 交易索引 */
-    index: number;
-    /** 交易哈希 */
-    hash: string;
-    /** 是否成功 */
-    success: boolean;
-    /** 区块号 */
-    blockNumber?: number;
-    /** Gas 使用量 */
-    gasUsed?: string;
-    /** 有效 Gas Price */
-    effectiveGasPrice?: string;
-    /** Gas 费用（BNB/ETH） */
-    gasCost?: string;
-    /** 错误信息 */
-    error?: string;
-}
-/**
- * Merkle 客户端
- */
-export declare class MerkleClient {
-    private provider;
-    private chainId;
-    private chainName;
-    private blockNumberCache;
-    private static BLOCK_CACHE_TTL_MS;
-    constructor(config: MerkleConfig);
-    /**
-     * 获取 Provider
-     */
-    getProvider(): JsonRpcProvider;
-    /**
-     * 获取当前区块号（带缓存，减少 RPC 调用）
-     * @param forceRefresh 是否强制刷新缓存
-     */
-    getBlockNumber(forceRefresh?: boolean): Promise<number>;
-    /**
-     * 获取 Gas 价格信息
-     */
-    getFeeData(): Promise<import("ethers").FeeData>;
-    /**
-     * 获取网络状态（用于 Bundle 参数优化）
-     */
-    getNetworkStatus(): Promise<NetworkStatus>;
-    /**
-     * 发送捆绑交易（底层方法）
-     *
-     * @param params Bundle 参数
-     * @returns Bundle Hash
-     */
-    sendBundleRaw(params: BundleParams): Promise<string>;
-    /**
-     * 发送捆绑交易（高级方法，带智能优化和重试）
-     *
-     * @param options 发送选项
-     * @returns Bundle 结果
-     */
-    sendBundle(options: SendBundleOptions): Promise<BundleResult>;
-    /**
-     * 等待 Bundle 中的交易确认
-     *
-     * @param txHashes 交易哈希列表
-     * @param confirmations 确认数（默认 1）
-     * @param timeout 超时时间（毫秒，默认 120000）
-     * @returns 交易结果列表
-     */
-    waitForBundleConfirmation(txHashes: string[], confirmations?: number, timeout?: number): Promise<TransactionResult[]>;
-    /**
-     * 准备并签名交易（辅助方法）
-     *
-     * @param wallet 钱包
-     * @param transactions 交易列表
-     * @param options 可选参数
-     * @returns 已签名的交易数组
-     */
-    signTransactions(wallet: Wallet, transactions: TransactionLike[], options?: {
-        /** 起始 Nonce（可选，默认从链上获取） */
-        startNonce?: number;
-        /** Gas Price（可选，默认从链上获取并提高 50%） */
-        gasPrice?: bigint;
-        /** Gas Price 增幅百分比（默认 50，即提高 50%） */
-        gasPriceMultiplier?: number;
-    }): Promise<string[]>;
-    /**
-     * 检查交易是否已包含在区块中
-     *
-     * @param txHash 交易哈希
-     * @returns 是否已包含
-     */
-    isTransactionIncluded(txHash: string): Promise<boolean>;
-    /**
-     * 等待达到目标区块
-     *
-     * @param targetBlock 目标区块号
-     * @param maxAttempts 最大尝试次数（默认 10）
-     * @param intervalMs 检查间隔（毫秒，默认 1000）
-     * @returns 是否达到目标区块
-     */
-    waitForBlock(targetBlock: number, maxAttempts?: number, intervalMs?: number): Promise<boolean>;
-    /**
-     * 获取当前 Provider 的统计信息（用于调试）
-     */
-    getProviderInfo(): {
-        chainId: number;
-        chainName: string;
-        rpcUrl: string;
-    };
-}
-/**
- * 创建 Merkle 客户端的便捷函数
- */
-export declare function createMerkleClient(apiKey: string, chainId?: 56 | 1): MerkleClient;