${sortedAddresses.map((holder, index) => {
const globalRank = globalRankMap.get(holder.address) || (index + 1);
const processedData = {
rank: index + 1,
rankIndex: globalRank, // 使用全局排名
address: holder.address,
balance: formatNumber(holder.balance),
usdValue: formatNumber(holder.usd_value),
netflowUsd: formatNumber(holder.netflow_usd),
netflowClass: (holder.netflow_usd || 0) >= 0 ? 'statistic-gmgn-profit-positive' : 'statistic-gmgn-profit-negative',
profit: formatNumber(holder.profit),
profitSign: holder.profit >= 0 ? '+' : '',
profitClass: holder.profit >= 0 ? 'statistic-gmgn-profit-positive' : 'statistic-gmgn-profit-negative',
profitChange: holder.profit_change ? (holder.profit_change * 100).toFixed(1) + '%' : 'N/A',
profitChangeClass: (holder.profit_change || 0) >= 0 ? 'statistic-gmgn-profit-positive' : 'statistic-gmgn-profit-negative',
exchangeName: getExchangeName(holder),
transferName: (holder.native_transfer && holder.native_transfer.name) || (holder.transfer && holder.transfer.name) || 'N/A',
amountPercentage: holder.amount_percentage ? (holder.amount_percentage * 100).toFixed(2) + '%' : 'N/A',
sellPercentage: holder.sell_amount_percentage ? (holder.sell_amount_percentage * 100).toFixed(2) + '%' : '0.00%' // 筹码已卖
};
return `
基本信息
${generateDetailItemHTML('💎', '持仓', processedData.balance)}
${generateDetailItemHTML('✨', '持仓占比', processedData.amountPercentage, 'highlight', true)}
${generateDetailItemHTML('📉', '筹码已卖', processedData.sellPercentage, processedData.sellPercentage === '0.00%' ? 'profit-positive' : 'warning')}
${generateDetailItemHTML('💰', '净流入', '$' + processedData.netflowUsd, processedData.netflowClass.includes('positive') ? 'profit-positive' : 'profit-negative')}
${generateDetailItemHTML('📈', '盈亏', processedData.profitSign + '$' + processedData.profit, processedData.profitClass.includes('positive') ? 'profit-positive' : 'profit-negative')}
${generateDetailItemHTML('🚀', '倍数', processedData.profitChange, processedData.profitChangeClass.includes('positive') ? 'profit-positive' : 'profit-negative')}
${generateDetailItemHTML('🏢', '交易所', processedData.exchangeName, 'highlight', true)}
${generateDetailItemHTML('🏷️', '标签', processedData.transferName)}
`;
}).join('')}
${isLargeDataset ? `
` : ''}
已卖筹码地址数:
${soldAddressCount}
总数量:
${allProcessedData.length}
总持仓占比:
${(totalHoldingPercentage * 100).toFixed(2)}%
${isLargeDataset ? `
` : ''}
基本信息
${generateSuspiciousLabelsHTML(holder.suspiciousLabels)}
${generateDetailItemHTML('💎', '持仓', holder.balance)}
${generateDetailItemHTML('✨', '持仓占比', holder.amountPercentage, 'highlight', true)}
${generateDetailItemHTML('📉', '筹码已卖', holder.sellPercentage, holder.sellPercentage === '0.00%' ? 'profit-positive' : 'warning')}
${generateDetailItemHTML('💰', '净流入', '$' + holder.netflowUsd, holder.netflowClass.includes('positive') ? 'profit-positive' : 'profit-negative')}
${generateDetailItemHTML('📈', '盈亏', holder.profitSign + '$' + holder.profit, holder.profitClass.includes('positive') ? 'profit-positive' : 'profit-negative')}
${generateDetailItemHTML('🚀', '倍数', holder.profitChange, holder.profitChangeClass.includes('positive') ? 'profit-positive' : 'profit-negative')}
${holder.solBalance ? generateDetailItemHTML('⭐', 'SOL餘額', holder.solBalance, 'highlight') : ''}
`;
// 添加地址复制功能
const addressElement = item.querySelector('.statistic-gmgn-result-address');
addressElement.addEventListener('click', () => {
navigator.clipboard.writeText(holder.address).then(() => {
addressElement.style.backgroundColor = '#16a34a';
addressElement.style.color = 'white';
setTimeout(() => {
addressElement.style.backgroundColor = '';
addressElement.style.color = '';
}, 1000);
});
});
resultsList.appendChild(item);
});
// ESC键关闭处理函数
const escKeyHandler = (e) => {
if (e.key === 'Escape') {
document.body.removeChild(modal);
document.removeEventListener('keydown', escKeyHandler);
}
};
document.addEventListener('keydown', escKeyHandler);
// 5. 绑定导出Excel按钮事件 - 导出完整数据而非分页数据
const exportBtn = modal.querySelector('#statistic-export-excel-btn');
if (exportBtn) {
exportBtn.addEventListener('click', () => {
exportToExcel(allProcessedData, title, caAddress, showSolBalance);
});
}
// 6. 分页控制逻辑
if (isLargeDataset) {
// 渲染指定页面的数据
function renderPage(page) {
currentPage = page;
const currentPageData = getCurrentPageData(page);
// 清空当前列表
const resultsList = document.getElementById('statistic-gmgn-results-list');
resultsList.innerHTML = '';
// 重新渲染当前页数据
currentPageData.forEach((holder, index) => {
const item = document.createElement('div');
item.className = 'statistic-gmgn-result-item';
item.innerHTML = `
基本信息
${generateSuspiciousLabelsHTML(holder.suspiciousLabels)}
${generateDetailItemHTML('💎', '持仓', holder.balance)}
${generateDetailItemHTML('✨', '持仓占比', holder.amountPercentage, 'highlight', true)}
${generateDetailItemHTML('📉', '筹码已卖', holder.sellPercentage, holder.sellPercentage === '0.00%' ? 'profit-positive' : 'warning')}
${generateDetailItemHTML('💰', '净流入', '$' + holder.netflowUsd, holder.netflowClass.includes('positive') ? 'profit-positive' : 'profit-negative')}
${generateDetailItemHTML('📈', '盈亏', holder.profitSign + '$' + holder.profit, holder.profitClass.includes('positive') ? 'profit-positive' : 'profit-negative')}
${generateDetailItemHTML('🚀', '倍数', holder.profitChange, holder.profitChangeClass.includes('positive') ? 'profit-positive' : 'profit-negative')}
${holder.solBalance ? generateDetailItemHTML('⭐', 'SOL餘額', holder.solBalance, 'highlight') : ''}
`;
// 添加地址复制功能
const addressElement = item.querySelector('.statistic-gmgn-result-address');
addressElement.addEventListener('click', () => {
navigator.clipboard.writeText(holder.address).then(() => {
addressElement.style.backgroundColor = '#16a34a';
addressElement.style.color = 'white';
setTimeout(() => {
addressElement.style.backgroundColor = '';
addressElement.style.color = '';
}, 1000);
});
});
resultsList.appendChild(item);
});
// 更新分页按钮状态
const prevBtn = modal.querySelector('#statistic-prev-page');
const nextBtn = modal.querySelector('#statistic-next-page');
const currentSpan = modal.querySelector('.statistic-pagination-current');
if (prevBtn) {
prevBtn.disabled = (page === 1);
}
if (nextBtn) {
nextBtn.disabled = (page === totalPages);
}
if (currentSpan) {
currentSpan.textContent = `第 ${page} 页 / 共 ${totalPages} 页`;
}
}
// 绑定分页按钮事件
const prevBtn = modal.querySelector('#statistic-prev-page');
const nextBtn = modal.querySelector('#statistic-next-page');
if (prevBtn) {
prevBtn.addEventListener('click', () => {
if (currentPage > 1) {
renderPage(currentPage - 1);
}
});
}
if (nextBtn) {
nextBtn.addEventListener('click', () => {
if (currentPage < totalPages) {
renderPage(currentPage + 1);
}
});
}
}
// 7. 绑定关闭按钮事件
modal.querySelector('.statistic-gmgn-modal-close').addEventListener('click', () => {
document.body.removeChild(modal);
document.removeEventListener('keydown', escKeyHandler);
});
// 点击模态框外部关闭
modal.addEventListener('click', (e) => {
if (e.target === modal) {
document.body.removeChild(modal);
document.removeEventListener('keydown', escKeyHandler);
}
});
}
// 数字格式化函数
function formatNumber(num) {
if (num === null || num === undefined) return 'N/A';
// 處理負數：保留負號，對絕對值進行格式化
const isNegative = num < 0;
const absNum = Math.abs(num);
let formatted;
if (absNum >= 1000000000) {
formatted = (absNum / 1000000000).toFixed(2) + 'B';
} else if (absNum >= 1000000) {
formatted = (absNum / 1000000).toFixed(2) + 'M';
} else if (absNum >= 1000) {
formatted = (absNum / 1000).toFixed(2) + 'K';
} else {
formatted = absNum.toFixed(2);
}
return isNegative ? '-' + formatted : formatted;
}
// Excel导出功能
function exportToExcel(data, title, caAddress, showSolBalance) {
try {
// 创建工作表数据
const worksheetData = [];
// 添加标题行
const headers = ['排名', '地址', '持仓数量', '持仓占比', '筹码已卖', 'USD价值', '净流入USD', '盈亏USD', '盈亏倍数'];
if (showSolBalance) {
headers.push('SOL餘額');
}
worksheetData.push(headers);
// 添加数据行
data.forEach((holder, index) => {
const row = [
holder.rank,
holder.address,
holder.balance,
holder.amountPercentage,
holder.sellPercentage,
holder.usdValue,
holder.netflowUsd,
(holder.profitSign || '') + holder.profit,
holder.profitChange
];
if (showSolBalance) {
row.push(holder.solBalance || 'N/A');
}
worksheetData.push(row);
});
// 创建工作簿
const wb = XLSX.utils.book_new();
const ws = XLSX.utils.aoa_to_sheet(worksheetData);
// 设置列宽
const colWidths = [
{wch: 6}, // 排名
{wch: 45}, // 地址
{wch: 15}, // 持仓数量
{wch: 10}, // 持仓比例
{wch: 10}, // 已卖比例
{wch: 15}, // USD价值
{wch: 15}, // 净流入
{wch: 15}, // 盈亏
{wch: 12} // 倍数
];
if (showSolBalance) {
colWidths.push({wch: 12}); // SOL餘額
}
ws['!cols'] = colWidths;
// 添加工作表到工作簿
XLSX.utils.book_append_sheet(wb, ws, title);
// 生成文件名
const timestamp = new Date().toISOString().slice(0, 19).replace(/:/g, '-');
const fileName = `${title}_${caAddress ? caAddress.slice(0, 8) : 'data'}_${timestamp}.xlsx`;
// 下载文件
XLSX.writeFile(wb, fileName);
// 显示成功提示
const exportBtn = document.querySelector('#statistic-export-excel-btn');
if (exportBtn) {
const originalText = exportBtn.textContent;
exportBtn.textContent = '✅ 导出成功';
exportBtn.style.backgroundColor = '#059669';
setTimeout(() => {
exportBtn.textContent = originalText;
exportBtn.style.backgroundColor = '';
}, 2000);
}
} catch (error) {
console.error('Excel导出失败:', error);
showModernToast('导出失败，请检查浏览器控制台了解详情', 'error');
}
}
// 根据类型获取对应的地址数据（优化版本）
function getAddressByType(type) {
if (!GlobalState.interceptedData?.data?.list) return [];
// 检查缓存
const currentHash = getDataHash(interceptedData);
const cacheKey = `${type}_${currentHash}`;
if (GlobalState.cache.filteredResults.has(cacheKey)) {
console.log('[性能优化] 使用缓存的过滤结果:', type);
return GlobalState.cache.filteredResults.get(cacheKey);
}
console.log('[性能优化] 重新过滤数据:', type);
const currentTime = Math.floor(Date.now() / 1000);
const sevenDaysInSeconds = 7 * 24 * 60 * 60;
const holders = GlobalState.interceptedData.data.list;
let result;
switch (type) {
case 'fullPosition':
result = holders.filter(h =>
h.sell_amount_percentage === 0 &&
(!h.token_transfer_out || !h.token_transfer_out.address)
);
break;
case 'profitable':
result = holders.filter(h => h.profit > 0);
break;
case 'losing':
result = holders.filter(h => h.profit < 0);
break;
case 'active24h':
result = holders.filter(h => h.last_active_timestamp > currentTime - 86400);
break;
case 'diamondHands':
result = holders.filter(h => h.maker_token_tags?.includes('diamond_hands'));
break;
case 'newAddress':
result = holders.filter(h => h.tags?.includes('fresh_wallet'));
break;
case 'holdingLessThan7Days':
result = holders.filter(h =>
h.start_holding_at &&
(currentTime - h.start_holding_at) < sevenDaysInSeconds
);
break;
case 'highProfit':
result = holders.filter(h => h.profit_change > 5);
break;
case 'suspicious':
result = holders.filter(h =>
h.is_suspicious ||
h.transfer_in ||
(h.maker_token_tags && (
h.maker_token_tags.includes('rat_trader') ||
h.maker_token_tags.includes('bundler')
))
);
break;
case 'lowSolBalance':
result = holders.filter(h =>
h.native_balance && (h.native_balance / 1000000000) < 1
);
break;
case 'tokenTransferIn':
result = holders.filter(h =>
h.token_transfer_in && h.token_transfer_in.address && h.token_transfer_in.address.trim() !== ''
);
break;
case 'exchangeAddresses':
result = holders.filter(h => isExchangeAddress(h));
break;
case 'addedPosition':
// 返回加仓地址列表
result = GlobalState.addedPositionAddresses;
break;
default:
result = [];
}
// 缓存结果
GlobalState.cache.filteredResults.set(cacheKey, result);
console.log('[性能优化] 过滤结果已缓存:', type, 'count:', result.length);
return result;
}
// 获取类型对应的中文标题
function getTypeTitle(type) {
const titles = {
'fullPosition': '满仓地址',
'profitable': '盈利地址',
'losing': '亏损地址',
'active24h': '24小时活跃地址',
'diamondHands': '钻石手地址',
'newAddress': '新地址',
'holdingLessThan7Days': '持仓小于7天的地址',
'highProfit': '5倍以上盈利地址',
'suspicious': '可疑地址',
'lowSolBalance': 'SOL餘額不足1的地址',
'tokenTransferIn': '代币转入地址',
'exchangeAddresses': '交易所地址',
'addedPosition': '回调60%后加仓地址'
};
return titles[type] || '未知类型';
}
// ===== API拦截器 (增强版 - 避免冲突) =====
// 使用Proxy包装而不是直接覆盖，避免与其他插件冲突
const ApiInterceptor = {
initialized: false,
originalFetch: window.fetch,
xhrPrototypeOpen: XMLHttpRequest.prototype.open,
// 安全的Fetch拦截 (使用链式调用保留其他拦截器)
hookFetch() {
if (!window.fetch) return;
const self = this;
const prevFetch = window.fetch;
window.fetch = function (...args) {
const [url] = args;
try {
if (self.isTargetApi(url)) {
return prevFetch.apply(this, args).then(response => {
if (response && response.ok) {
// 异步处理，不阻塞主流程，传递URL
self.processResponse(response.clone(), url).catch(err => {
console.error('[拦截器] 处理响应失败:', err);
});
}
return response;
}).catch(err => {
console.error('[拦截器] Fetch失败:', err);
throw err;
});
}
} catch (err) {
console.error('[拦截器] Fetch拦截异常:', err);
}
return prevFetch.apply(this, args);
};
},
// 安全的XHR拦截 (使用open钩子获取URL)
hookXHR() {
const self = this;
const originalOpen = XMLHttpRequest.prototype.open;
XMLHttpRequest.prototype.open = function (method, url, ...rest) {
// 保存URL到实例，供后续使用
this.__interceptor_url = url;
this.__interceptor_method = method;
// 只对目标API添加监听
if (self.isTargetApi(url)) {
// 使用一次性监听器，避免重复绑定
const loadHandler = function () {
// 确保请求已完成且成功
if (this.readyState === 4 && this.status === 200) {
try {
// 验证 responseText 不为空
if (this.responseText && this.responseText.trim()) {
// 传递URL到processResponse
self.processResponse(this.responseText, this.__interceptor_url).catch(err => {
console.error('[拦截器] XHR响应处理失败:', err);
});
} else {
console.warn('[拦截器] XHR响应为空，跳过处理');
}
} catch (err) {
console.error('[拦截器] XHR异常:', err);
}
// 清理
this.removeEventListener('readystatechange', loadHandler);
}
};
this.addEventListener('readystatechange', loadHandler);
}
return originalOpen.apply(this, [method, url, ...rest]);
};
},
// 初始化拦截器
init() {
if (this.initialized) {
console.warn('[拦截器] 已初始化，跳过重复初始化');
return;
}
try {
this.hookFetch();
this.hookXHR();
this.initialized = true;
console.log('[拦截器] API拦截器初始化成功');
} catch (err) {
console.error('[拦截器] 初始化失败:', err);
}
},
// 判断是否为目标API
isTargetApi(url) {
if (typeof url !== 'string') return false;
try {
// 检查是否是token_holders API且包含limit参数
const isTokenHoldersApi = /vas\/api\/v1\/token_holders\/(sol|eth|base|bsc|tron)(\/|$|\?)/i.test(url);
const hasLimitParam = /[?&]limit=/i.test(url);
const isHoldersTarget = isTokenHoldersApi && hasLimitParam;
if (isHoldersTarget) {
// 修复: 支持所有链的CA地址提取
const match = url.match(/vas\/api\/v1\/token_holders\/(sol|eth|base|bsc|tron)\/([^/?]+)/i);
if (match && match[2]) {
const newCA = match[2];
const newChain = match[1].toLowerCase();
// 检测CA变化，重置状态
if (GlobalState.currentCAAddress && GlobalState.currentCAAddress !== newCA) {
console.log('[加仓功能] 检测到CA变化:', GlobalState.currentCAAddress, '->', newCA);
GlobalState.reset();
}
GlobalState.currentCAAddress = newCA;
GlobalState.currentChain = newChain;
console.log('[加仓功能] 提取CA地址:', newCA, '链:', newChain);
// 提取API参数
this.extractApiParams(url);
// 新增：提取到API参数后，主动获取K线数据
console.log('[加仓功能] 准备主动获取K线数据...');
setTimeout(() => {
this.fetchKlineData();
}, 500); // 延迟500ms确保参数已设置
}
}
// 注意：移除了K线API的拦截逻辑，改为主动获取
return isHoldersTarget;
} catch (err) {
console.error('[拦截器] URL判断异常:', err);
return false;
}
},
// 新增：提取API参数
extractApiParams(url) {
try {
const urlObj = new URL(url, 'https://gmgn.ai');
const params = new URLSearchParams(urlObj.search);
const apiParams = {
device_id: params.get('device_id'),
fp_did: params.get('fp_did'),
client_id: params.get('client_id'),
from_app: params.get('from_app'),
app_ver: params.get('app_ver'),
tz_name: params.get('tz_name'),
tz_offset: params.get('tz_offset'),
app_lang: params.get('app_lang'),
os: params.get('os')
};
GlobalState.apiParams = apiParams;
console.log('[加仓功能] API参数已提取:', apiParams);
} catch (err) {
console.error('[加仓功能] 提取API参数失败:', err);
}
},
// 新增：主动获取K线数据
async fetchKlineData() {
try {
const { currentCAAddress, currentChain, apiParams, klineDataFetched } = GlobalState;
// 检查是否已获取过K线数据
if (klineDataFetched) {
console.log('[K线获取] K线数据已获取，跳过重复请求');
return;
}
// 检查必要参数
if (!currentCAAddress) {
console.warn('[K线获取] 缺少代币地址');
return;
}
if (!currentChain) {
console.warn('[K线获取] 缺少链网络信息');
return;
}
if (!apiParams) {
console.warn('[K线获取] 缺少API参数，等待参数提取...');
return;
}
console.log('[K线获取] ========== 开始获取K线数据 ==========');
console.log('[K线获取] 代币地址:', currentCAAddress);
console.log('[K线获取] 链网络:', currentChain);
console.log('[K线获取] API参数:', apiParams);
// 构建URL参数
const params = new URLSearchParams({
...apiParams,
resolution: '1h',
from: '0',
to: Date.now().toString(),
limit: '500'
});
// 构建完整URL
const url = `https://gmgn.ai/api/v1/token_mcap_candles/${currentChain}/${currentCAAddress}?${params.toString()}`;
console.log('[K线获取] 请求URL:', url);
// 发起请求
const response = await fetch(url, {
method: 'GET',
credentials: 'include',
headers: {
'Accept': 'application/json',
'Referer': 'https://gmgn.ai/',
'User-Agent': navigator.userAgent
}
});
console.log('[K线获取] 响应状态:', response.status, response.statusText);
if (!response.ok) {
console.error('[K线获取] 请求失败，HTTP状态:', response.status);
return;
}
const data = await response.json();
console.log('[K线获取] ✅ 成功获取K线数据');
console.log('[K线获取] 数据结构:', {
hasData: !!data.data,
hasList: !!data.data?.list,
listLength: data.data?.list?.length || 0
});
// 处理K线数据
if (data && data.data && data.data.list) {
console.log('[K线获取] 开始处理K线数据...');
this.processKlineData(data);
// 标记K线数据已获取，避免重复请求
GlobalState.klineDataFetched = true;
console.log('[K线获取] 已标记K线数据为已获取状态');
} else {
console.warn('[K线获取] K线数据格式异常');
}
console.log('[K线获取] ========== K线数据获取完成 ==========');
} catch (err) {
console.error('[K线获取] ❌ 获取K线数据失败:', err);
console.error('[K线获取] 错误堆栈:', err.stack);
}
},
// 新增：处理K线数据
processKlineData(data) {
try {
console.log('[K线处理] ========== 开始处理K线数据 ==========');
if (!data || !data.data || !data.data.list || data.data.list.length === 0) {
console.warn('[K线处理] K线数据为空');
return;
}
const klineList = data.data.list;
console.log(`[K线处理] K线数据条数: ${klineList.length}`);
console.log('[K线处理] 第一条K线:', klineList[0]);
console.log('[K线处理] 最后一条K线:', klineList[klineList.length - 1]);
// 存储K线数据
GlobalState.klineData = data;
// 计算ATH (历史最高价)
let athPrice = 0;
let athTimestamp = 0;
klineList.forEach(candle => {
const high = parseFloat(candle.high);
if (high > athPrice) {
athPrice = high;
athTimestamp = candle.time;
}
});
GlobalState.athInfo = {
price: athPrice,
timestamp: athTimestamp
};
console.log(`[K线处理] ATH价格: ${athPrice}, 时间: ${new Date(athTimestamp).toLocaleString()}`);
// 检测回调60%
this.detectRebound60(klineList, athPrice, athTimestamp);
console.log('[K线处理] ========== K线数据处理完成 ==========');
} catch (err) {
console.error('[K线处理] ❌ 处理K线数据失败:', err);
console.error('[K线处理] 错误堆栈:', err.stack);
}
},
// 新增：检测回调60%
detectRebound60(klineList, athPrice, athTimestamp) {
try {
console.log('[加仓功能] 开始检测回调60%...');
// 只检查ATH之后的蜡烛图，且排除ATH所在的那根K线（避免单根K线内的波动）
const candlesAfterATH = klineList.filter(c => c.time > athTimestamp);
if (candlesAfterATH.length === 0) {
console.log('[加仓功能] ATH是最后一根K线，无后续数据');
GlobalState.rebound60Timestamp = null;
return;
}
for (let candle of candlesAfterATH) {
const low = parseFloat(candle.low);
const reboundPercent = ((athPrice - low) / athPrice) * 100;
// 打印每根K线的回调情况（前几根）
if (candlesAfterATH.indexOf(candle) < 5) {
console.log(`[加仓功能] 时间: ${new Date(candle.time).toLocaleString()}, 最低价: ${low}, 回调: ${reboundPercent.toFixed(2)}%`);
}
if (reboundPercent >= 60) {
GlobalState.rebound60Timestamp = candle.time;
console.log(`[加仓功能] ✅ 发现回调60%! 时间: ${new Date(candle.time).toLocaleString()}`);
console.log(`[加仓功能] ATH价格: ${athPrice} (${new Date(athTimestamp).toLocaleString()}), 最低价: ${low}, 回调: ${reboundPercent.toFixed(2)}%`);
// 延迟触发加仓分析，等待持有者数据加载
console.log('[加仓功能] 等待持有者数据加载...');
setTimeout(() => {
this.analyzeAddedPositions();
}, 2000); // 延迟2秒
return;
}
}
console.log('[加仓功能] 未检测到回调60%');
GlobalState.rebound60Timestamp = null;
} catch (err) {
console.error('[加仓功能] 检测回调60%失败:', err);
}
},
// 新增：分析加仓地址
async analyzeAddedPositions(retryCount = 0) {
const maxRetries = 3;
console.log('[加仓功能] 开始分析TOP20加仓情况...');
// 检查是否已完成分析
if (GlobalState.addedPositionCompleted) {
console.log('[加仓功能] 已完成分析，跳过重复请求');
return;
}
// 检查必要条件
if (!GlobalState.rebound60Timestamp) {
console.warn('[加仓功能] 未检测到回调60%，无法分析加仓');
GlobalState.addedPositionCompleted = true; // 标记为完成（无需分析）
updateStatsDisplay(calculateStats(), false);
return;
}
if (!GlobalState.interceptedData || !GlobalState.interceptedData.data || !GlobalState.interceptedData.data.list) {
if (retryCount < maxRetries) {
console.warn(`[加仓功能] 持有者数据不可用，${retryCount + 1}/${maxRetries} 次重试，2秒后重试...`);
setTimeout(() => this.analyzeAddedPositions(retryCount + 1), 2000);
return;
} else {
console.error('[加仓功能] 持有者数据不可用，已达到最大重试次数');
GlobalState.addedPositionCompleted = true; // 标记为完成（失败）
updateStatsDisplay(calculateStats(), false);
return;
}
}
if (!GlobalState.apiParams) {
console.warn('[加仓功能] API参数未提取，无法查询交易历史');
GlobalState.addedPositionCompleted = true; // 标记为完成（失败）
updateStatsDisplay(calculateStats(), false);
return;
}
if (GlobalState.addedPositionLoading) {
console.log('[加仓功能] 正在加载中，跳过重复请求');
return;
}
console.log('[加仓功能] ✅ 所有数据已就绪，开始分析...');
GlobalState.addedPositionLoading = true;
// 立即更新UI显示"加载中"状态
updateStatsDisplay(calculateStats(), false);
try {
const holders = GlobalState.interceptedData.data.list;
// 获取TOP20持有者
const top20 = holders
.sort((a, b) => b.amount_percentage - a.amount_percentage)
.slice(0, 20);
console.log(`[加仓功能] TOP20持有者地址:`, top20.map(h => h.address));
// 分批查询，避免限流 (每批5个)
const batchSize = 5;
const addedAddresses = [];
for (let i = 0; i < top20.length; i += batchSize) {
const batch = top20.slice(i, i + batchSize);
console.log(`[加仓功能] 处理第 ${Math.floor(i / batchSize) + 1} 批，共 ${batch.length} 个地址`);
const batchPromises = batch.map(holder =>
this.checkIfAddedPosition(holder.address)
);
const results = await Promise.all(batchPromises);
results.forEach((isAdded, index) => {
if (isAdded) {
addedAddresses.push(batch[index]);
}
});
// 批次之间延迟500ms
if (i + batchSize < top20.length) {
await new Promise(resolve => setTimeout(resolve, 500));
}
}
GlobalState.addedPositionAddresses = addedAddresses;
GlobalState.addedPositionCompleted = true; // 标记为完成
console.log(`[加仓功能] ✅ 加仓分析完成！共 ${addedAddresses.length} 个地址加仓`);
console.log(`[加仓功能] 加仓地址:`, addedAddresses.map(h => h.address));
// 更新UI显示
updateStatsDisplay(calculateStats(), false);
} catch (err) {
console.error('[加仓功能] 分析加仓失败:', err);
GlobalState.addedPositionCompleted = true; // 即使失败也标记为完成
updateStatsDisplay(calculateStats(), false);
} finally {
GlobalState.addedPositionLoading = false;
}
},
// 新增：检查单个地址是否加仓
async checkIfAddedPosition(walletAddress) {
try {
const { apiParams, currentCAAddress, rebound60Timestamp, currentChain } = GlobalState;
// 根据链选择API端点和构建URL
let url;
if (currentChain === 'sol') {
// SOL链使用 vas API
const params = new URLSearchParams({
type: 'buy',
wallet: walletAddress,
token: currentCAAddress,
limit: '50',
...apiParams
});
// 添加type=sell
params.append('type', 'sell');
url = `https://gmgn.ai/vas/api/v1/wallet_activity/sol?${params.toString()}`;
} else {
// BSC/ETH/BASE/TRON链使用 defi API
const params = new URLSearchParams({
wallet: walletAddress,
token: currentCAAddress,
limit: '50',
...apiParams
});
url = `https://gmgn.ai/defi/quotation/v1/wallet_token_activity/${currentChain}?${params.toString()}`;
}
console.log(`[加仓功能] 查询交易历史: ${walletAddress.substring(0, 8)}... [${currentChain}]`);
const response = await fetch(url, {
credentials: 'include',
headers: {
'Accept': 'application/json'
}
});
if (!response.ok) {
console.warn(`[加仓功能] 请求失败: ${response.status}`);
return false;
}
const data = await response.json();
// 根据链处理不同的响应结构
let activities;
if (currentChain === 'sol') {
// SOL: data.data.activities
if (!data || !data.data || !data.data.activities) {
console.warn(`[加仓功能] 无效的响应数据 (SOL)`);
return false;
}
activities = data.data.activities;
} else {
// BSC/ETH/BASE/TRON: data.data.activities (根据用户提供的BSC API结构)
if (!data || !data.data || !data.data.activities) {
console.warn(`[加仓功能] 无效的响应数据 (${currentChain})`);
return false;
}
activities = data.data.activities;
}
// 过滤出基准时间戳之后的交易
const rebound60TimestampSeconds = Math.floor(rebound60Timestamp / 1000);
const activitiesAfterRebound = activities.filter(
act => act.timestamp >= rebound60TimestampSeconds
);
if (activitiesAfterRebound.length === 0) {
console.log(`[加仓功能] ${walletAddress.substring(0, 8)}... 回调后无交易`);
return false;
}
// 计算净买入 (兼容不同链的字段名)
let totalBuy = 0;
let totalSell = 0;
activitiesAfterRebound.forEach(act => {
// 兼容不同字段名: token_amount (SOL) 或 amount (其他链)
const amount = parseFloat(act.token_amount || act.amount || 0);
// 兼容不同字段名: event_type (SOL) 或 type (其他链)
const eventType = act.event_type || act.type;
if (eventType === 'buy') {
totalBuy += amount;
} else if (eventType === 'sell') {
totalSell += amount;
}
});
const netBuy = totalBuy - totalSell;
const isAdded = netBuy > 0;
console.log(`[加仓功能] ${walletAddress.substring(0, 8)}... 买入: ${totalBuy.toFixed(2)}, 卖出: ${totalSell.toFixed(2)}, 净买: ${netBuy.toFixed(2)}, 加仓: ${isAdded ? '✅' : '❌'}`);
return isAdded;
} catch (err) {
console.error(`[加仓功能] 检查地址失败:`, err);
return false;
}
},
// 处理响应 (带请求队列管理)
async processResponse(response, url = '') {
const requestId = ++GlobalState.requestQueue.lastRequestId;
GlobalState.requestQueue.pending++;
console.log(`[请求队列] 新请求 ID:${requestId}, 待处理:${GlobalState.requestQueue.pending}`);
try {
let data;
if (typeof response === 'string') {
// 验证字符串不为空
if (!response || !response.trim()) {
console.warn('[拦截器] 响应字符串为空');
return;
}
try {
data = JSON.parse(response);
} catch (parseError) {
console.error('[拦截器] JSON解析失败:', parseError, '响应内容:', response.substring(0, 200));
return;
}
} else if (response.json) {
data = await response.json();
} else {
throw new Error('无效的响应格式');
}
// 只处理最新的请求
if (requestId !== GlobalState.requestQueue.lastRequestId) {
console.log(`[请求队列] 丢弃过期请求 ID:${requestId}`);
return;
}
// 注意：K线数据已改为主动获取，不再从拦截器处理
// 处理持有者数据
GlobalState.interceptedData = data;
const currentStats = calculateStats();
if (currentStats) {
if (GlobalState.isFirstLoad) {
GlobalState.initialStats = currentStats;
GlobalState.initialCAAddress = GlobalState.currentCAAddress;
GlobalState.isFirstLoad = false;
updateStatsDisplay(currentStats, true);
} else {
const isSameCA = GlobalState.currentCAAddress === GlobalState.initialCAAddress;
updateStatsDisplay(currentStats, !isSameCA);
if (!isSameCA) {
GlobalState.initialStats = currentStats;
GlobalState.initialCAAddress = GlobalState.currentCAAddress;
GlobalState.isDownloadInProgress = false;
console.log('[状态管理] CA变更，状态已更新');
}
}
}
// 新增：持有者数据加载完成后，检查是否需要触发加仓分析
if (GlobalState.rebound60Timestamp &&
!GlobalState.addedPositionLoading &&
!GlobalState.addedPositionCompleted) {
console.log('[加仓功能] 持有者数据已就绪，触发加仓分析...');
this.analyzeAddedPositions();
}
} catch (err) {
console.error('[拦截器] 处理响应错误:', err);
} finally {
GlobalState.requestQueue.pending--;
console.log(`[请求队列] 请求完成 ID:${requestId}, 剩余:${GlobalState.requestQueue.pending}`);
}
}
};
// 兼容旧代码的辅助函数 (已废弃，保留以防引用)
function isTargetApi(url) {
return ApiInterceptor.isTargetApi(url);
}
// 计算数据哈希值用于缓存
function getDataHash(data) {
return JSON.stringify({
length: data?.data?.list?.length || 0,
timestamp: data?.data?.list?.[0]?.last_active_timestamp || 0,
caAddress: GlobalState.currentCAAddress
});
}
// 3. 计算所有统计指标（优化版本 + 缓存过期检查）
function calculateStats() {
if (!GlobalState.interceptedData?.data?.list) return null;
// 检查缓存有效性
const currentHash = getDataHash(GlobalState.interceptedData);
if (GlobalState.cache.lastDataHash === currentHash &&
GlobalState.cache.calculatedStats &&
!GlobalState.isCacheExpired()) {
// 缓存命中，但需要更新addedPosition（因为它独立于持有者数据）
const cachedStats = GlobalState.cache.calculatedStats;
cachedStats.addedPosition = GlobalState.addedPositionAddresses.length;
return cachedStats;
}
const currentTime = Math.floor(Date.now() / 1000);
const sevenDaysInSeconds = 7 * 24 * 60 * 60; // 7天的秒数
const holders = GlobalState.interceptedData.data.list;
const stats = {
fullPosition: 0, // 全仓
profitable: 0, // 盈利
losing: 0, // 亏损
active24h: 0, // 24h活跃
diamondHands: 0, // 钻石手
newAddress: 0, // 新地址
highProfit: 0, // 10x盈利
suspicious: 0, // 新增：可疑地址
holdingLessThan7Days: 0, // 新增：持仓小于7天
lowSolBalance: 0, // 新增：SOL餘額小於1的地址
tokenTransferIn: 0, // 新增：代币转入地址数
exchangeAddresses: 0, // 新增：交易所地址数
addedPosition: 0 // 新增：回调60%后加仓的地址数
};
holders.forEach(holder => {
// 满判断条件：1.没有卖出；2.没有出货地址
if (holder.sell_amount_percentage === 0 &&
(!holder.token_transfer_out || !holder.token_transfer_out.address)) {
stats.fullPosition++;
}
if (holder.profit > 0) stats.profitable++;
if (holder.profit < 0) stats.losing++;
if (holder.last_active_timestamp > currentTime - 86400) stats.active24h++;
if (holder.maker_token_tags?.includes('diamond_hands')) stats.diamondHands++;
if (holder.tags?.includes('fresh_wallet')) stats.newAddress++;
if (holder.profit_change > 5) stats.highProfit++;
// 增强版可疑地址检测
if (
holder.is_suspicious ||
holder.transfer_in ||
(holder.maker_token_tags && (
holder.maker_token_tags.includes('rat_trader') ||
holder.maker_token_tags.includes('bundler')
))
) {
stats.suspicious++;
}
// 新增7天持仓统计
if (holder.start_holding_at &&
(currentTime - holder.start_holding_at) < sevenDaysInSeconds) {
stats.holdingLessThan7Days++;
}
// 新增低SOL餘額統計（小於1 SOL）
if (holder.native_balance && (holder.native_balance / 1000000000) < 1) {
stats.lowSolBalance++;
}
// 新增代币转入地址统计
if (holder.token_transfer_in && holder.token_transfer_in.address && holder.token_transfer_in.address.trim() !== '') {
stats.tokenTransferIn++;
}
// 新增交易所地址统计
if (isExchangeAddress(holder)) {
stats.exchangeAddresses++;
}
});
// 新增：统计加仓地址数量
stats.addedPosition = GlobalState.addedPositionAddresses.length;
// 缓存计算结果
GlobalState.cache.lastDataHash = currentHash;
GlobalState.cache.calculatedStats = stats;
GlobalState.cache.filteredResults.clear(); // 清空过滤缓存
GlobalState.cache.cacheTime = Date.now(); // 记录缓存时间
return stats;
}
// ===== DOM监听器管理 (内存泄漏修复) =====
const DOMManager = {
observer: null,
isObserving: false,
targetSelector: '.flex.overflow-x-auto.overflow-y-hidden.scroll-smooth.w-full',
// 启动监听
startObserving() {
if (this.isObserving) {
console.warn('[DOM管理] 已在监听中');
return;
}
this.observer = new MutationObserver(() => {
const targetContainer = document.querySelector(this.targetSelector);
if (targetContainer && !targetContainer.querySelector('#statistic-gmgn-stats-item')) {
injectStatsItem(targetContainer);
}
});
// 立即检查一次
const initialContainer = document.querySelector(this.targetSelector);
if (initialContainer) {
injectStatsItem(initialContainer);
}
// 开始监听
this.observer.observe(document.body, {
childList: true,
subtree: true,
attributes: false
});
this.isObserving = true;
console.log('[DOM管理] 监听器已启动');
},
// 停止监听
stopObserving() {
if (this.observer) {
this.observer.disconnect();
this.observer = null;
this.isObserving = false;
console.log('[DOM管理] 监听器已停止');
}
},
// 清理所有DOM元素
cleanup() {
const statsItem = document.getElementById('statistic-gmgn-stats-item');
if (statsItem) {
statsItem.remove();
console.log('[DOM管理] 统计面板已移除');
}
const modals = document.querySelectorAll('.statistic-gmgn-modal');
modals.forEach(modal => modal.remove());
console.log('[DOM管理] 弹窗已清理');
}
};
function injectStatsItem(container) {
if (container.querySelector('#statistic-gmgn-stats-item')) return;
const isSol = isSolNetwork();
const statsItem = document.createElement('div');
statsItem.id = 'statistic-gmgn-stats-item';
statsItem.className = 'statistic-gmgn-stats-container';
const headerClass = isSol ? 'statistic-gmgn-stats-header sol-network' : 'statistic-gmgn-stats-header';
const dataClass = isSol ? 'statistic-gmgn-stats-data sol-network' : 'statistic-gmgn-stats-data';
statsItem.innerHTML = `