El término "nuevas emisiones" es familiar para todos en el mercado de valores. Solicitar anticipadamente para obtener los activos y disfrutar de los beneficios del descubrimiento de precios en el momento de la cotización oficial: esta es la lógica central de las nuevas emisiones. El mundo de las criptomonedas también tiene oportunidades de nuevas emisiones, y con una frecuencia mucho mayor que la del mercado de valores. Los principales exchanges centralizados lanzan nuevos contratos perpetuos casi cada pocos días, y estas oportunidades están abiertas a todos por igual.

En las primeras etapas del lanzamiento de un contrato, el mercado aún no ha fijado completamente el precio de esta criptomoneda, la elasticidad del precio es enorme y, a menudo, se producen movimientos de precio mucho mayores que en condiciones normales en un corto período de tiempo. Determinar la dirección con anticipación y entrar en el mercado en el momento de la apertura: ahí reside la oportunidad de las nuevas emisiones de contratos perpetuos. Pero aquí está el problema: antes del lanzamiento de un nuevo contrato, casi no sabemos nada sobre esta criptomoneda. Antecedentes del equipo, modelo económico del token, sentimiento del mercado, tasas de financiación... esta información requiere mucho tiempo para recopilar y analizar. Entrar sin un conocimiento suficiente no es diferente a apostar. Depender del trabajo manual para investigar cada nueva criptomoneda es imposible seguir el ritmo.

Por eso, el flujo de trabajo que presentamos hoy está diseñado para resolver este problema: permitir que el sistema comience automáticamente a recopilar datos en el momento en que se publica el anuncio, realice análisis de IA de forma continua y nos ayude a establecer una base de conocimiento suficiente antes de la apertura. Todo el flujo de trabajo funciona 24/7 de forma automática, sin necesidad de supervisión manual. Anuncio de nueva criptomoneda, recopilación de datos, análisis de IA, entrada en la apertura: todo se completa automáticamente.

Arquitectura general: dos líneas de ejecución paralelas

La arquitectura de esta estrategia se divide en dos líneas de ejecución.

La línea de análisis se ejecuta cíclicamente con intervalos de tiempo más largos, responsable de monitorear continuamente los anuncios de nuevas cotizaciones, recopilar datos multidimensionales, invocar análisis de IA y acumular cada conclusión del análisis como un registro histórico. La línea de ejecución se ejecuta en ciclos de alta frecuencia con intervalos de tiempo muy rápidos, responsable de detectar en tiempo real si la nueva criptomoneda ya se ha listado en el exchange. Una vez detectado el listado, lee inmediatamente los resultados del análisis, determina si se debe entrar en el mercado y supervisa continuamente el take profit y stop loss de las posiciones mantenidas.

Las dos líneas tienen funciones claras: la línea de análisis proporciona la dirección, y la línea de ejecución es responsable de la implementación.

Línea de análisis: Primer paso: detectar nuevas criptomonedas y crear una cola de seguimiento

Al iniciarse la línea de análisis, primero inicializa el estado global, registrando datos básicos como el capital inicial y el número de ejecuciones:

            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);
}

Luego, obtiene los anuncios oficiales de Binance para identificar las nuevas criptomonedas que se van a listar en contratos perpetuos:

            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' } }
);

Una vez identificada una nueva criptomoneda, el sistema la añade a la cola de seguimiento y le asigna una marca de estado: antes del listado es PRE_LISTING (pre-seguimiento), el día del listado cambia a LAUNCH_DAY (día de lanzamiento), después de la entrada pasa a TRADING (en trading), y una vez completado se establece como DONE y se elimina automáticamente de la cola.

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

De esta manera, el sistema solo se centra en los objetivos realmente valiosos en ese momento, sin desperdiciar esfuerzos en oportunidades ya caducadas.

Línea de análisis: Segundo paso: recopilación de datos multidimensionales

Una vez detectada la nueva criptomoneda, el sistema comienza inmediatamente a recopilar datos desde tres dimensiones.

Datos fundamentales a través de la API de CoinMarketCap para obtener la capitalización de mercado, ratio de circulación, ranking de 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
  };
}

Datos de opinión pública a través de Brave Search para obtener noticias recientes relacionadas con el fondo de capital, dinámicas del equipo, planes de desbloqueo, etc., utilizando tres combinaciones de palabras clave diferentes para buscar por separado:

            javascript
            
            
function fetchBraveNews(coin) {
  const key = $vars.braveKey || '';
  const queries = [
    '"' + coin + '" token funding team',
    '"' + coin + '" vesting unlock schedule',
    '"' + coin + '" binance futures listing'
  ];
  // Para cada consulta, llama a la API de Brave Search, filtra resultados que contengan el nombre de la criptomoneda, elimina duplicados y devuelve
}

Datos de mercado simultáneamente recopila datos de contratos de cuatro exchanges: Bybit, OKX, Gate y HTX, incluyendo indicadores clave como la tasa de financiación, el interés abierto y el diferencial de precios. Tomando OKX como ejemplo:

            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 falló:', e.message); return null; }
}

La verificación cruzada entre múltiples exchanges puede evitar eficazmente el sesgo de una única fuente de datos y proporciona una comprensión más tridimensional de las nuevas monedas.

Línea de análisis: Tercer paso – Análisis de IA con memoria histórica

Es el diseño más central de todo el flujo de trabajo.

Desde la publicación del anuncio hasta el lanzamiento oficial de una nueva moneda suelen pasar varios días. Durante este período, el sistema recopila datos repetidamente y solicita análisis de IA repetidamente. La clave radica en: en cada análisis, se pasan a la IA todas las conclusiones anteriores, permitiéndole hacer nuevas inferencias sobre la base de juicios históricos.

Leer registros históricos e inyectarlos en el 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 '(Este es el primer análisis de esta moneda, no hay registros históricos)';
  return history.map(h => {
    const ai = h.aiConclusion;
    return [
      '### Análisis n.º ' + h.order,
      '- Tiempo: ' + h.timestamp + ' | Horas hasta lanzamiento: ' + h.hoursToLaunch + ' | Fase: ' + h.phase,
      '- Conclusión: ' + ai.direction + ', Confianza: ' + ai.confidence + '%, Riesgo: ' + ai.riskLevel,
      '- Tendencia: ' + (ai.trendConsistency || 'Inicial'),
      '- Momento de entrada: ' + (ai.entryTiming || '-'),
      '- Juicio integral: ' + ai.summary
    ].join('\n');
  }).join('\n\n');
}

El análisis de la IA sigue varios principios centrales: cuando la dirección histórica es consistente, la confianza aumenta con cada análisis; cuando se produce un cambio de dirección, debe indicarse claramente si se trata de una señal real o ruido a corto plazo; cuando el juicio histórico es fluctuante, la confianza debe ser conservadora y no aumentarse ciegamente. La IA produce en última instancia una conclusión estructurada:

            javascript
            
            
// Estructura JSON de salida de la IA
{
  "order": 3,
  "direction": "largo|corto|esperar",
  "confidence": 76,                      // entero de 0 a 100
  "trendConsistency": "inicial|fortalecida|mantenida|debilitada|reversión",
  "reversalType": "señal real|ruido a corto plazo|null",
  "entryTiming": "inmediato|retroceso_N", // retroceso_5 significa esperar una corrección del 5%
  "priceRange": { "low": 128, "high": 130 },
  "leverage": 10,
  "stopLoss": 5,                         // porcentaje de stop loss
  "takeProfit": 15,                      // porcentaje de take profit
  "riskLevel": "alto|medio|bajo",
  "riskPoints": ["Punto de riesgo 1", "Punto de riesgo 2"],
  "keyChanges": "Cambio de datos más importante respecto al análisis anterior",
  "summary": "Juicio integral en menos de 100 caracteres"
}

Una vez completado el análisis, la conclusión se almacena en el historial, y al mismo tiempo se actualiza la estrategia final de esa moneda para que la línea de ejecución pueda leerla.

            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
}));

Si la dirección es siempre consistente, la confianza aumentará con cada análisis; si aparece una inversión de dirección, la IA debe dar una razón clara. De esta forma, los juicios acumulados son mucho más fiables que un análisis independiente único.

Línea de ejecución: Cuarto paso – Detección de listado y entrada segura

El bucle de alta frecuencia de la línea de ejecución detecta si la nueva moneda ya aparece en la lista de contratos del exchange mediante exchange.GetMarkets(). Una vez detectado el listado, se pasa primero por un filtro de seguridad:

            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; }

Tras pasar todas las comprobaciones, se ejecuta la operación según el momento de entrada indicado por la IA. Si es entrada inmediata, se calcula la cantidad de contratos y se coloca la orden directamente:

            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);
}

Si la IA determina que la prima de apertura es demasiado alta y opta por esperar un retroceso para entrar, el sistema registra el precio objetivo y continúa sondeando:

            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');

Si la espera supera las 2 horas sin activarse, se considera que la oportunidad ha pasado y se abandona automáticamente la entrada.

Línea de ejecución: Quinto paso – Monitoreo de posición y take profit/stop loss

Tras la entrada, la línea de ejecución monitorea continuamente el estado de la posición. El take profit y el stop loss funcionan con dos mecanismos en paralelo:

            javascript
            
            
const TP_SL = {
  DEFAULT_SL:        10,  // Stop loss por defecto 10%
  DEFAULT_TP:        25,  // Take profit fijo por defecto 25%
  TRAILING_TRIGGER:  30,  // Activar trailing stop cuando la ganancia flotante alcance 30%
  TRAILING_DRAWDOWN:  8   // Porcentaje de retroceso para trailing stop: 8%
};

// Actualizar el registro de ganancia flotante máxima
if (pnlPct / 100 > maxProfit) {
  maxProfit = pnlPct / 100;
  _G(maxProfitKey, maxProfit);
}

// Si la ganancia flotante alcanza el umbral, se activa automáticamente el trailing stop
if (tpDrawdown === 0 && maxPnlPct >= TP_SL.TRAILING_TRIGGER) {
  tpDrawdown = TP_SL.TRAILING_DRAWDOWN;
  _G(tpDrawKey, tpDrawdown);
}

// Evaluar las tres condiciones de cierre en orden; se ejecuta la que se active primero
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 fijo';

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);
}

El trailing stop permite que las ganancias sigan corriendo, mientras que el take profit fijo y el stop loss mantienen la línea de defensa. Los tres actúan simultáneamente, ejecutándose el que se active primero.

Demostración del rendimiento real en funcionamiento

Una vez que la estrategia está en marcha, el panel muestra cuatro tablas de estado en tiempo real: Resumen de la cuenta muestra el tiempo de ejecución, el patrimonio actual y la tasa de rendimiento total; Cola de seguimiento muestra el estado de cada moneda monitoreada, la cuenta regresiva para el listado y el número de análisis; Resumen del análisis de IA muestra la conclusión completa del análisis más reciente de cada moneda; Monitoreo de posiciones en tiempo real muestra la ganancia/pérdida flotante, la ganancia máxima flotante y la activación del trailing stop, con soporte para cierre manual en línea y modificación de parámetros de stop loss.

Tomando como ejemplo el EWYUSDT, que se prepara para listarse próximamente, el sistema ha completado múltiples análisis consecutivos desde que lo detectó en el anuncio. En cada análisis, la IA ha indicado dirección larga y la tendencia se etiqueta como "fortalecimiento continuo". Esto es precisamente el efecto del mecanismo de memoria histórica: múltiples análisis con la misma dirección indican que la señal alcista es estable, no un error puntual por fluctuaciones de datos. El último juicio integral: las tasas de financiación de OKX y HTX son estables y positivas, las noticias relacionadas con el listado del perpetuo de ETF de Corea del Sur son en general positivas. La IA da dirección larga, confianza del 76%, sugiere entrada inmediata en apertura en el rango de precio de 128 a 130, apalancamiento 10x, stop loss 5%, take profit 15%, riesgo medio.

Límites de la estrategia y advertencia de riesgos

El problema central que resuelve esta estrategia es: antes del listado de una nueva moneda, utilizar un enfoque sistemático para reemplazar el juicio manual sobre esa moneda y convertir las conclusiones en señales de entrada ejecutables. Pero es necesario reconocer claramente sus limitaciones:

Las nuevas monedas son inherentemente muy volátiles; el stop loss puede activarse en el primer minuto de la apertura. La calidad del juicio de la IA depende de la integridad de los datos; cuanto menos datos haya antes del listado, más conservador será el juicio. El apalancamiento amplifica las ganancias y pérdidas; ninguna estrategia puede garantizar ganancias estables.

Un control adecuado del tamaño de la posición es la premisa más importante para usar esta estrategia.

Este sistema es más un punto de partida. El "nuevo listado" es un ámbito de gran profundidad, donde las dimensiones de las señales, la determinación del momento de entrada y los detalles de la gestión de la posición ofrecen un amplio margen de optimización. Si tienes experiencia y conocimientos propios en este campo, te invitamos a compartirlos en los comentarios; la colaboración enriquece el camino. Toda estrategia conlleva riesgo de pérdidas; antes de usarla, debes perfeccionar la lógica de la estrategia según tu propia situación.

Código fuente de la estrategia: Estrategia de IA inteligente para nuevos listados de Binance