O termo "lançamento de novas ações" (打新) é familiar a todos no mercado de ações. A ideia é comprar ações na oferta pública inicial e aproveitar a descoberta de preço no momento da listagem oficial – essa é a lógica central. No mundo das criptomoedas também existem oportunidades de "lançamento de novas moedas", e com uma frequência muito maior do que no mercado de ações. As principais exchanges centralizadas lançam novos contratos perpétuos quase a cada poucos dias, e essas oportunidades estão abertas a todos de forma igualitária.

No início da listagem de um contrato, a precificação do mercado para essa moeda ainda não é completa, a elasticidade de preço é enorme e, muitas vezes, ocorrem movimentos de alta ou baixa muito maiores do que em negociações normais em um curto espaço de tempo. Antecipar a direção correta e entrar no mercado no momento da abertura – é nisso que consiste a oportunidade de "lançamento de novas moedas" em contratos perpétuos. Mas o problema está aqui: antes da listagem de um novo contrato, sabemos quase nada sobre essa moeda. Antecedentes da equipe, modelo econômico do token, sentimento do mercado, taxa de funding… essas informações exigem muito tempo para serem coletadas e analisadas. Entrar no mercado sem um conhecimento suficiente não é diferente de jogar. Contar com pesquisa manual para cada nova moeda é impossível de acompanhar o ritmo.

Portanto, o fluxo de trabalho apresentado hoje foi criado para resolver esse problema – fazer o sistema começar automaticamente a coletar dados no momento em que o anúncio é emitido, realizar análises contínuas de IA e nos ajudar a estabelecer uma base de conhecimento suficiente antes da abertura do mercado. Todo o fluxo de trabalho funciona 24 horas por dia, sem necessidade de monitoramento manual: anúncio de novas moedas, coleta de dados, análise de IA e entrada no mercado na abertura, tudo é feito automaticamente.

Arquitetura geral: duas linhas de execução paralelas

A arquitetura desta estratégia é dividida em duas linhas de execução.

A linha de análise opera em ciclos com intervalos de tempo mais longos, responsável por monitorar continuamente os anúncios de listagem de novas moedas, coletar dados multidimensionais, acionar a IA para análise e acumular cada conclusão da análise em um histórico. A linha de execução opera em ciclos de alta frequência com intervalos de tempo muito rápidos, responsável por detectar em tempo real se uma nova moeda já foi listada na exchange. Quando a listagem é detectada, ela imediatamente lê os resultados da análise, decide se deve entrar no mercado e monitora continuamente o stop loss e take profit das posições.

As duas linhas têm divisões claras de tarefas – a linha de análise fornece a direção, e a linha de execução é responsável pela implementação.

Linha de análise: Primeiro passo – Descobrir novas moedas e estabelecer uma fila de monitoramento

Quando a linha de análise é iniciada, primeiro inicializa o estado global, registrando dados básicos como capital inicial, número de execuções, etc.:

            javascript
            
            
if (_G('nl_initialized') === null) {
  _G('nl_initialized', true);
  _G('nl_trackingList', JSON.stringify([]));
  _G('nl_STARTTIME', Date.now());
  const initAccount = exchange.GetAccount();
  _G('nl_initmoney', $vars.initmoney || initAccount.Balance);
}

Em seguida, puxa os anúncios oficiais da Binance para identificar novas moedas que serão listadas em contratos perpétuos:

            javascript
            
            
const raw = HttpQuery(
  'https://www.binance.com/bapi/composite/v1/public/cms/article/list/query?type=1&pageNo=1&pageSize=10',
  { method: 'GET', headers: { 'User-Agent': 'Mozilla/5.0', 'clienttype': 'web' } }
);

Quando uma nova moeda é identificada, o sistema a insere na fila de monitoramento e marca seu status: antes da listagem é PRE_LISTING (pré-monitoramento), no dia da listagem muda para LAUNCH_DAY (dia de abertura), após a entrada no mercado entra em TRADING (em negociação), e quando concluída é alterada para DONE e removida automaticamente da fila.

            javascript
            
            
trackingList.push({
  symbol,
  launchDate,
  status: isLaunchDay ? 'LAUNCH_DAY' : 'PRE_LISTING',
  discoveredAt: now.toISOString(),
  hoursToLaunch: isLaunchDay ? '今日发行' : hoursToLaunch,
  analysisCount: 0,
  lastAnalyzedAt: null
});

Dessa forma, o sistema se concentra apenas nos alvos que realmente têm valor no momento, sem desperdiçar energia em oportunidades já expiradas.

Linha de análise: Segundo passo – Coleta de dados multidimensionais

Após descobrir uma nova moeda, o sistema começa imediatamente a coletar dados a partir de três dimensões.

Dados fundamentais são obtidos através da API CoinMarketCap, incluindo capitalização de mercado, proporção em circulação, classificação CMC, etc.:

            javascript
            
            
function fetchCMC(coin) {
  const key = $vars.cmcApiKey || '';
  const raw = HttpQuery(
    'https://pro-api.coinmarketcap.com/v1/cryptocurrency/quotes/latest?symbol=' + coin + '&convert=USD',
    { method: 'GET', headers: { 'X-CMC_PRO_API_KEY': key, 'Accept': 'application/json' } }
  );
  const c = JSON.parse(raw).data[coin];
  const q = c.quote.USD;
  const supply = c.max_supply || c.total_supply;
  return {
    name: c.name, rank: c.cmc_rank,
    circulatingSupply: c.circulating_supply,
    circulationRatio: supply
      ? parseFloat((c.circulating_supply / supply * 100).toFixed(2))
      : null,
    spotPrice: q.price,
    change1h: q.percent_change_1h,
    change24h: q.percent_change_24h,
    change7d: q.percent_change_7d,
    volume24h: q.volume_24h,
    marketCap: q.market_cap,
    fullyDilutedMarketCap: q.fully_diluted_market_cap
  };
}

Dados de sentimento são obtidos através do Brave Search, coletando notícias recentes relacionadas ao fundo da moeda, dinâmica da equipe, cronograma de desbloqueio, etc., usando três combinações diferentes de palavras-chave para pesquisar separadamente:

            javascript
            
            
function fetchBraveNews(coin) {
  const key = $vars.braveKey || '';
  const queries = [
    '"' + coin + '" token funding team',
    '"' + coin + '" vesting unlock schedule',
    '"' + coin + '" binance futures listing'
  ];
  // Para cada query, chama a Brave Search API, filtra resultados que correspondem ao nome da moeda, deduplica e retorna
}

Dados de mercado simultaneamente coletam cotações de contratos das exchanges Bybit, OKX, Gate e HTX, incluindo taxa de funding, open interest, spread e outros indicadores chave. Tomando OKX como exemplo:

            javascript
            
            
function fetchOKX(coin) {
  try {
    const instId = coin + '-USDT-SWAP';
    const tkRaw = HttpQuery('https://www.okx.com/api/v5/market/ticker?instId=' + instId,
      { method: 'GET', headers: { 'Accept': 'application/json' } });
    const tk = JSON.parse(tkRaw).data && JSON.parse(tkRaw).data[0];
    if (!tk) return null;
    Sleep(150);

    let fundingRate = null, nextFundingRate = null, fundingTime = null, nextFundingTime = null;
    try {
      const frRaw = HttpQuery('https://www.okx.com/api/v5/public/funding-rate?instId=' + instId,
        { method: 'GET', headers: { 'Accept': 'application/json' } });
      const fr = JSON.parse(frRaw).data && JSON.parse(frRaw).data[0];
      if (fr) {
        fundingRate = parseFloat(fr.fundingRate);
        nextFundingRate = fr.nextFundingRate !== '' ? parseFloat(fr.nextFundingRate) : null;
        fundingTime = fr.fundingTime;
        nextFundingTime = fr.nextFundingTime;
      }
    } catch(e) {}
    Sleep(150);

    let openInterest = null;
    try {
      const oiRaw = HttpQuery('https://www.okx.com/api/v5/public/open-interest?instType=SWAP&instId=' + instId,
        { method: 'GET', headers: { 'Accept': 'application/json' } });
      const oiData = JSON.parse(oiRaw).data && JSON.parse(oiRaw).data[0];
      if (oiData) openInterest = parseFloat(oiData.oiUsd);
    } catch(e) {}

    const last = parseFloat(tk.last);
    const sodUtc0 = parseFloat(tk.sodUtc0);

    return {
      price: last,
      bid1: parseFloat(tk.bidPx), bid1Size: parseFloat(tk.bidSz),
      ask1: parseFloat(tk.askPx), ask1Size: parseFloat(tk.askSz),
      spread: parseFloat((parseFloat(tk.askPx) - parseFloat(tk.bidPx)).toFixed(8)),
      change24h: parseFloat(((last - sodUtc0) / sodUtc0 * 100).toFixed(4)),
      high24h: parseFloat(tk.high24h), low24h: parseFloat(tk.low24h), open24h: parseFloat(tk.open24h),
      volume24h: parseFloat(tk.vol24h), volCcy24h: parseFloat(tk.volCcy24h),
      openInterest,
      fundingRate, nextFundingRate, fundingTime, nextFundingTime
    };
  } catch(e) { Log('OKX失败:', e.message); return null; }
}

A validação cruzada entre múltiplas exchanges evita eficazmente os desvios de uma única fonte de dados e proporciona uma compreensão mais completa dos novos tokens.

Linha de Análise: Terceiro Passo – Análise de IA com Memória Histórica

Este é o design mais central de todo o fluxo de trabalho.

Desde o anúncio até o lançamento oficial de um novo token, muitas vezes leva alguns dias. Durante esse período, o sistema coleta dados repetidamente e chama a análise de IA diversas vezes. O ponto-chave é: cada análise transmite todas as conclusões anteriores para a IA, permitindo que ela faça novas inferências com base em julgamentos históricos.

Ler o histórico e injetar no Prompt:

            javascript
            
            
const historyKey = 'nl_history_' + symbol;
const history = JSON.parse(_G(historyKey) || '[]');
const orderNum = history.length + 1;

function buildHistorySection(history) {
  if (history.length === 0) return '(Esta é a primeira análise para este token, sem histórico)';
  return history.map(h => {
    const ai = h.aiConclusion;
    return [
      '### Análise nº ' + h.order,
      '- Hora: ' + h.timestamp + ' | Faltam ' + h.hoursToLaunch + 'h para o lançamento | Fase: ' + h.phase,
      '- Conclusão: ' + ai.direction + ', Confiança ' + ai.confidence + '%, Risco ' + ai.riskLevel,
      '- Tendência: ' + (ai.trendConsistency || 'Inicial'),
      '- Momento de entrada: ' + (ai.entryTiming || '-'),
      '- Julgamento geral: ' + ai.summary
    ].join('\n');
  }).join('\n\n');
}

A análise de IA segue alguns princípios centrais: quando a direção histórica é consistente, a confiança aumenta a cada análise; quando ocorre uma reversão de direção, deve-se deixar claro se é um sinal real ou ruído de curto prazo; quando os julgamentos históricos são inconsistentes, a confiança deve ser conservadora, sem aumentos cegos. A IA produz uma conclusão estruturada no final:

            javascript
            
            
// Estrutura JSON de saída da IA
{
  "order": 3,
  "direction": "做多|做空|观望",
  "confidence": 76,                      // 0-100 inteiro
  "trendConsistency": "初始|强化|维持|弱化|反转",
  "reversalType": "真实信号|短期噪音|null",
  "entryTiming": "immediate|drawdown_N", // drawdown_5 significa esperar uma queda de 5%
  "priceRange": { "low": 128, "high": 130 },
  "leverage": 10,
  "stopLoss": 5,                         // percentagem de stop loss
  "takeProfit": 15,                      // percentagem de take profit
  "riskLevel": "高|中|低",
  "riskPoints": ["Ponto de risco 1", "Ponto de risco 2"],
  "keyChanges": "Mudanças de dados mais importantes em relação à última análise",
  "summary": "Julgamento geral em até 100 caracteres"
}

Após a conclusão da análise, a conclusão é armazenada no histórico e a estratégia final do token é atualizada para ser lida pela linha de execução:

            javascript
            
            
const record = {
  order: item.orderNum,
  timestamp: new Date().toISOString(),
  phase: item.status,
  hoursToLaunch: item.hoursToLaunch,
  currentData: item.currentData,
  aiConclusion: aiResult
};
history.push(record);
_G('nl_history_' + symbol, JSON.stringify(history));

_G('nl_strategy_' + symbol, JSON.stringify({
  symbol,
  updatedAt: new Date().toISOString(),
  phase: item.status,
  historyCount: history.length,
  aiResult
}));

Se a direção permanece sempre consistente, a confiança aumenta a cada análise; se houver uma reversão de direção, a IA deve fornecer uma justificativa explícita. Dessa forma, os julgamentos acumulados são muito mais confiáveis do que uma única análise independente.

Linha de Execução: Etapa 4 — Detecção de Listagem e Entrada Segura

A linha de execução realiza um loop de alta frequência, usando exchange.GetMarkets() para detectar se uma nova moeda já apareceu na lista de contratos da exchange. Assim que a listagem é detectada, primeiro passa por uma verificação de segurança:

            javascript
            
            
if (ai.direction === '观望') { updateStatus(symbol, 'DONE'); continue; }
if (ai.riskLevel === '高')   { updateStatus(symbol, 'DONE'); continue; }
if (ai.confidence < CONFIG.MIN_CONFIDENCE) { updateStatus(symbol, 'DONE'); continue; }
if (hasPosition(coin)) { updateStatus(symbol, 'TRADING'); continue; }

Após passar por todas as verificações, a operação é executada de acordo com o momento de entrada fornecido pela IA. Se for entrada imediata, a quantidade de contratos é calculada e a ordem é enviada diretamente:

            javascript
            
            
const leverage = Math.min(ai.leverage || 5, CONFIG.MAX_LEVERAGE);
exchange.SetMarginLevel(leverage);

const allocAmount = Math.min(CONFIG.POSITION_AMOUNT, account.Balance * 0.3);
const qty = calcContractAmount(allocAmount, price, market);

if (ai.direction === '做多') {
  exchange.SetDirection('buy');
  orderId = exchange.Buy(-1, qty);
} else if (ai.direction === '做空') {
  exchange.SetDirection('sell');
  orderId = exchange.Sell(-1, qty);
}

Se a IA julgar que o prêmio de abertura está muito alto, opta por aguardar uma entrada após um recuo. O sistema registra o preço alvo e continua consultando periodicamente:

            javascript
            
            
const targetPrice = ai.direction === '做多'
  ? openPrice * (1 - pct / 100)
  : openPrice * (1 + pct / 100);

_G(coin + '_nl_waitEntry', JSON.stringify({
  type: 'drawdown',
  waitStartTime: Date.now(),
  openPrice, targetPrice, drawdownPct: pct, ai
}));
updateStatus(symbol, 'TRADING_WAIT');

Se a espera ultrapassar 2 horas sem que o gatilho seja acionado, a oportunidade é considerada perdida e a entrada é automaticamente abandonada.

Linha de Execução: Etapa 5 — Monitoramento de Posição e Take Profit/Stop Loss

Após a entrada, a linha de execução monitora continuamente o status da posição. O take profit e o stop loss operam com dois mecanismos em paralelo:

            javascript
            
            
const TP_SL = {
  DEFAULT_SL:        10,  // Stop loss padrão 10%
  DEFAULT_TP:        25,  // Take profit fixo padrão 25%
  TRAILING_TRIGGER:  30,  // Ativa trailing stop quando o lucro flutuante atinge 30%
  TRAILING_DRAWDOWN:  8   // Percentual de recuo para acionar o trailing stop
};

// Atualiza o registro de lucro flutuante máximo
if (pnlPct / 100 > maxProfit) {
  maxProfit = pnlPct / 100;
  _G(maxProfitKey, maxProfit);
}

// Lucro flutuante atinge o limite, ativa automaticamente o trailing stop
if (tpDrawdown === 0 && maxPnlPct >= TP_SL.TRAILING_TRIGGER) {
  tpDrawdown = TP_SL.TRAILING_DRAWDOWN;
  _G(tpDrawKey, tpDrawdown);
}

// Verifica as três condições de encerramento na ordem; a primeira a ser acionada é executada
let closeReason = null;
if (tpDrawdown > 0 && drawdown >= tpDrawdown) closeReason = 'Trailing Stop';
if (!closeReason && pnlPct <= -maxSL)          closeReason = 'Stop Loss';
if (!closeReason && pnlPct >= entry.takeProfit) closeReason = 'Take Profit Fixo';

if (closeReason) {
  if (isLong) { exchange.SetDirection('closebuy');  exchange.Sell(-1, amount); }
  else        { exchange.SetDirection('closesell'); exchange.Buy(-1, amount); }
  _G(maxProfitKey, null); _G(slKey, null); _G(tpDrawKey, null);
}

O trailing stop permite que o lucro corra o máximo possível, enquanto o take profit fixo e o stop loss protegem o resultado. Os três atuam simultaneamente, e o primeiro que for acionado é executado.

Demonstração do Desempenho Real

Após a execução da estratégia, o painel exibirá em tempo real quatro tabelas de status: Visão Geral da Conta mostra o tempo de execução, patrimônio atual e taxa de retorno total; Fila de Monitoramento exibe o status de cada moeda monitorada, contagem regressiva para listagem e número de análises; Resumo da Análise da IA apresenta a conclusão completa da análise mais recente para cada moeda; Monitoramento de Posição em Tempo Real mostra lucro flutuante, lucro máximo e status do trailing stop, permitindo encerramento manual online e ajuste dos parâmetros de stop loss.

Tomando como exemplo o EWYUSDT, que será listado em breve, o sistema começou a realizar múltiplas análises consecutivas desde que foi descoberto pelo anúncio. Em todas elas, a direção fornecida pela IA foi de compra (long), com a tendência marcada como "fortalecimento contínuo" — isso é o mecanismo de memória histórica em ação. Análises consecutivas com a mesma direção indicam que o sinal de alta é estável, e não um erro causado por flutuações pontuais de dados. A última análise abrangente: as taxas de funding da OKX e HTX são consistentemente positivas, as notícias relacionadas à listagem do ETF perpétuo na Coreia são geralmente positivas, a IA recomenda direção de compra (long) com 76% de confiança, sugerindo entrada imediata na abertura entre 128 e 130, alavancagem de 10x, stop loss de 5%, take profit de 15% e risco médio.

Limitações da Estratégia e Aviso de Risco

O problema central que esta estratégia resolve é: antes da listagem de uma nova moeda, utilizar uma abordagem sistemática para substituir a cognição manual sobre essa moeda e converter as conclusões de julgamento em sinais de entrada executáveis. No entanto, é necessário reconhecer claramente suas limitações:

Novas moedas são extremamente voláteis; o stop loss pode ser acionado no primeiro minuto após a abertura. A qualidade do julgamento da IA depende da integridade dos dados; quanto menos dados antes da listagem, mais conservadora será a análise. A alavancagem amplifica ganhos e perdas, e nenhuma estratégia pode garantir lucros consistentes.

Controlar adequadamente o tamanho da posição é o pré-requisito mais importante para usar esta estratégia.

Este sistema atualmente é mais um ponto de partida. A listagem de novas moedas é uma área muito profunda, envolvendo dimensões de sinais, julgamento do momento de entrada e detalhes de gerenciamento de posição, todos com amplo espaço para otimização. Se você tem experiência e insights próprios nessa área, sinta-se à vontade para compartilhar nos comentários. Juntar ideias nos levará mais longe. Qualquer estratégia envolve risco de perda. Antes de usá-la, é essencial aperfeiçoar a lógica da estratégia de acordo com sua própria situação.

Código-fonte da Estratégia: Estratégia de IA para Novas Listagens na Binance