four-flap-meme-sdk 1.8.4 → 1.8.6

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

@@ -7,6 +7,13 @@ export type FourConfig = {
      * 如需自定义，可传入自己的代理地址
      */
     baseUrl?: string;
+    /**
+     * 图片上传备用代理 URL 列表
+     *
+     * 当主 baseUrl 触发 IP 限流（code -1038）时，自动依次尝试备用端点。
+     * 每个 URL 格式同 baseUrl，例如 'https://bscfourapi2.emit.tools'
+     */
+    uploadFallbackUrls?: string[];
 };
 export type GenerateNonceReq = {
     accountAddress: string;
@@ -90,10 +97,31 @@ export type CreateTokenResp = {
 };
 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>;

package/dist/shared/clients/four.js

@@ -1,7 +1,102 @@
+// ============================================================================
+// 图片上传缓存（按内容哈希去重，同一张图片只上传一次）
+// ✅ 使用 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`, {
@@ -28,22 +123,104 @@ export class FourClient {
         }
         return j.data; // access_token
     }
+    /**
+     * 上传图片到 Four.meme
+     *
+     * 优化策略：
+     * 1. 图片内容哈希缓存 —— 相同图片不重复上传，直接返回缓存 URL
+     * 2. 多端点轮换 —— 当某个代理 IP 触发限流（-1038）时自动切到下一个端点
+     */
     async uploadImage(accessToken, file, filename) {
-        const form = new FormData();
-        // 如果提供了文件名，使用它；否则根据 MIME 类型生成
+        // ✅ 先查缓存（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);
-        form.append('file', file, finalFilename);
-        const r = await fetch(`${this.baseUrl}/v1/private/token/upload`, {
+        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) {
-            throw new Error(`upload failed: ${JSON.stringify(j)}`);
+            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',

package/package.json

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