Le terme « nouvelle souscription » est bien connu dans le monde boursier. Réserver des actions à l’avance pour obtenir des titres, puis profiter des gains liés à la découverte du prix lors de la cotation officielle – tel est le principe fondamental de la nouvelle souscription. Dans le secteur des cryptomonnaies, il existe également des opportunités de nouvelle souscription, et leur fréquence est bien plus élevée que dans les actions. Les grandes bourses centralisées lancent presque tous les deux jours de nouveaux contrats perpétuels, et ces opportunités sont ouvertes à tous de manière égale.

En début de cotation d’un contrat, le marché n’a pas encore pleinement évalué cette cryptomonnaie, la flexibilité des prix est très forte, et ils enregistrent souvent des variations bien supérieures à celles des transactions normales en très peu de temps. Anticiper la direction, puis entrer sur le marché au moment de l’ouverture – c’est là que réside l’opportunité de nouvelle souscription des contrats perpétuels. Mais le problème est là aussi : avant la cotation d’un nouveau contrat, nous ne savons presque rien de cette cryptomonnaie. Contexte de l’équipe, modèle économique du jeton, sentiment du marché, taux de financement… Ces informations nécessitent beaucoup de temps pour être collectées et analysées. Entrer sur le marché sans une connaissance suffisante revient à jouer. Étudier manuellement chaque nouveau jeton est tout simplement impossible de suivre le rythme.

Le flux de travail présenté aujourd’hui a donc été conçu pour résoudre ce problème : permettre au système de commencer automatiquement à collecter des données dès l’annonce, de procéder à une analyse IA en continu, et de nous aider à établir une base de connaissance suffisante avant l’ouverture. L’ensemble du processus fonctionne 24 heures sur 24 sans surveillance humaine. L’annonce du nouveau jeton, la collecte des données, l’analyse IA et l’entrée sur le marché au moment de l’ouverture sont entièrement automatisés.

Architecture globale : deux lignes d’exécution parallèles

L’architecture de cette stratégie se compose de deux lignes d’exécution.

La ligne d’analyse s’exécute en boucle à intervalles longs. Elle est chargée de surveiller en continu les annonces de nouvelles cotations, de collecter des données multidimensionnelles, de solliciter l’IA pour l’analyse, et d’accumuler chaque conclusion d’analyse dans un historique. La ligne d’exécution s’exécute en boucle à haute fréquence, avec des intervalles très courts. Elle est chargée de détecter en temps réel si le nouveau jeton est déjà coté sur la bourse. Dès qu’elle détecte une cotation, elle lit immédiatement les résultats de l’analyse, décide d’entrer ou non en position, et surveille en continu le stop profit et le stop loss des positions.

Les deux lignes ont des rôles distincts : la ligne d’analyse donne la direction, la ligne d’exécution la met en œuvre.

Ligne d’analyse : première étape – Découverte des nouveaux jetons et création d’une file de suivi

Au démarrage de la ligne d’analyse, elle initialise d’abord l’état global, enregistre les données de base comme les fonds initiaux, le nombre d’exécutions, 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);
}

Ensuite, elle récupère les annonces officielles de Binance pour identifier les nouveaux jetons qui seront bientôt cotés en contrats perpétuels :

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

Une fois un nouveau jeton identifié, le système le pousse dans la file de suivi et lui attribue un statut : avant la cotation, c’est PRE_LISTING (pré‑suivi) ; le jour de la cotation, il passe à LAUNCH_DAY (jour d’ouverture) ; après l’entrée en position, il devient TRADING (en cours de trading) ; une fois terminé, il est marqué DONE et automatiquement retiré de la file.

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

Ainsi, le système ne s’intéresse qu’aux cibles réellement utiles du moment et ne gaspille pas d’énergie sur des opportunités périmées.

Ligne d’analyse : deuxième étape – Collecte de données multidimensionnelles

Après avoir découvert un nouveau jeton, le système commence immédiatement à collecter des données sur trois dimensions.

Les données fondamentales sont obtenues via l’API CoinMarketCap : capitalisation, ratio de circulation, classement 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
  };
}

Les données de sentiment sont collectées via Brave Search pour obtenir les actualités récentes sur le jeton : background des fonds, dynamique de l’équipe, calendrier de déblocage, etc. Trois combinaisons de mots‑clés différentes sont utilisées pour les recherches :

            javascript
            
            
function fetchBraveNews(coin) {
  const key = $vars.braveKey || '';
  const queries = [
    '"' + coin + '" token funding team',
    '"' + coin + '" vesting unlock schedule',
    '"' + coin + '" binance futures listing'
  ];
  // Pour chaque requête, appeler l’API Brave Search, filtrer les résultats contenant le nom du jeton, dédoublonner et retourner
}

Les données de marché sont collectées simultanément sur les bourses Bybit, OKX, Gate et HTX pour les contrats : taux de financement, intérêt ouvert, écart de prix, etc. Prenons OKX comme exemple :

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

La validation croisée entre plusieurs exchanges permet d'éviter efficacement les biais d'une source de données unique, et offre une perception plus complète des nouvelles cryptomonnaies.

Ligne d'analyse : Troisième étape – Analyse IA avec mémoire historique

C'est le cœur de toute la conception du workflow.

Entre l'annonce et le lancement officiel d'une nouvelle cryptomonnaie, il faut souvent plusieurs jours. Pendant cette période, le système collecte les données de manière répétée et appelle l'IA pour les analyser de manière réitérée. Le point clé : chaque analyse transmet à l'IA toutes les conclusions précédentes, lui permettant de faire de nouvelles déductions basées sur les jugements historiques.

Lire l'historique et l'injecter dans le 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 '(这是对该币种的第一次分析，暂无历史记录)';
  return history.map(h => {
    const ai = h.aiConclusion;
    return [
      '### 第' + h.order + '次分析',
      '- 时间: ' + h.timestamp + ' | 距上线' + h.hoursToLaunch + ' | 阶段:' + h.phase,
      '- 结论: ' + ai.direction + ', 置信度' + ai.confidence + '%, 风险' + ai.riskLevel,
      '- 趋势: ' + (ai.trendConsistency || '初始'),
      '- 入场时机: ' + (ai.entryTiming || '-'),
      '- 综合判断: ' + ai.summary
    ].join('\n');
  }).join('\n\n');
}

L'analyse IA suit plusieurs principes clés : lorsque la direction historique est cohérente, la confiance augmente avec le nombre d'occurrences ; en cas de renversement de direction, il faut clairement indiquer s'il s'agit d'un signal réel ou d'un bruit à court terme ; lorsque les jugements historiques sont hésitants, la confiance doit rester conservative, sans être gonflée aveuglément. L'IA génère finalement une conclusion structurée :

            javascript
            
            
// AI输出的JSON结构
{
  "order": 3,
  "direction": "做多|做空|观望",
  "confidence": 76,                      // 0-100整数
  "trendConsistency": "初始|强化|维持|弱化|反转",
  "reversalType": "真实信号|短期噪音|null",
  "entryTiming": "immediate|drawdown_N", // drawdown_5 表示等回调5%
  "priceRange": { "low": 128, "high": 130 },
  "leverage": 10,
  "stopLoss": 5,                         // 止损百分比
  "takeProfit": 15,                      // 止盈百分比
  "riskLevel": "高|中|低",
  "riskPoints": ["风险点1", "风险点2"],
  "keyChanges": "与上次相比最重要的数据变化",
  "summary": "100字以内综合判断"
}

Une fois l'analyse terminée, la conclusion est stockée dans l'historique, et la stratégie finale de cette cryptomonnaie est mise à jour pour être lue par la ligne d'exécution :

            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 direction reste toujours cohérente, la confiance augmente avec le nombre d'analyses ; si un retournement de direction se produit, l'IA doit fournir une raison claire. Ainsi, les jugements accumulés sont bien plus fiables qu'une analyse unique et indépendante.

Ligne d'exécution : quatrième étape – Détection de cotation et entrée sécurisée

La boucle haute fréquence de la ligne d'exécution utilise exchange.GetMarkets() pour détecter si la nouvelle pièce est déjà listée dans la liste des contrats perpétuels de l'échange. Une fois la cotation détectée, on passe d'abord par une vérification de sécurité :

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

Après avoir passé toutes les vérifications, on exécute l'opération selon le moment d'entrée donné par l'IA. Si l'entrée est immédiate, on calcule la quantité de contrat et on passe l'ordre directement :

            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 l'IA juge que la prime à l'ouverture est trop élevée et choisit d'attendre un repli pour entrer, le système enregistre le prix cible et interroge en continu :

            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 l'attente dépasse 2 heures sans déclenchement, l'opportunité est considérée comme passée et l'entrée est automatiquement abandonnée.

Ligne d'exécution : cinquième étape – Surveillance des positions et stop-loss / take-profit

Après l'entrée, la ligne d'exécution surveille en continu l'état de la position. Le stop-loss et le take-profit utilisent deux mécanismes simultanés :

            javascript
            
            
const TP_SL = {
  DEFAULT_SL:        10,  // Stop-loss par défaut 10%
  DEFAULT_TP:        25,  // Take-profit fixe par défaut 25%
  TRAILING_TRIGGER:  30,  // Déclenchement du trailing stop lorsque le profit flottant atteint 30%
  TRAILING_DRAWDOWN:  8   // Ratio de retrait du trailing stop 8%
};

// Mettre à jour le record de profit flottant maximum
if (pnlPct / 100 > maxProfit) {
  maxProfit = pnlPct / 100;
  _G(maxProfitKey, maxProfit);
}

// Profit flottant atteint le seuil, activer automatiquement le trailing stop
if (tpDrawdown === 0 && maxPnlPct >= TP_SL.TRAILING_TRIGGER) {
  tpDrawdown = TP_SL.TRAILING_DRAWDOWN;
  _G(tpDrawKey, tpDrawdown);
}

// Tester les trois conditions de clôture dans l'ordre, la première déclenchée est exécutée
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 fixe';

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

Le trailing stop permet de laisser courir les gains, tandis que le take-profit fixe et le stop-loss sécurisent les limites. Les trois fonctionnent simultanément et le premier déclenché est exécuté.

Affichage des résultats réels de l'exécution

Une fois la stratégie en cours, le tableau de bord affiche quatre tableaux d'état en temps réel : Résumé du compte (durée d'exécution, capital actuel et rendement total) ; File d'attente de suivi (statut de chaque pièce surveillée, compte à rebours avant cotation et nombre d'analyses) ; Résumé de l'analyse IA (conclusion complète de la dernière analyse pour chaque pièce) ; Surveillance des positions en temps réel (profit flottant, profit flottant maximal et activation du trailing stop, avec possibilité de clôture manuelle en ligne et de modification des paramètres de stop-loss).

Prenons l'exemple d'EWYUSDT, récemment en attente de cotation. Depuis que le système l'a repéré via l'annonce, il a effectué plusieurs analyses consécutives. À chaque fois, l'IA a donné une direction haussière, et la tendance est marquée comme « Renforcement continu » — c'est le mécanisme de mémoire historique qui joue : plusieurs analyses cohérentes indiquent que le signal haussier est stable, et non une erreur due à une fluctuation ponctuelle des données. Dernière évaluation complète : les taux de financement sur OKX et HTX sont stablement positifs, les actualités concernant la liste perpétuelle de l'ETF coréen sont globalement favorables, l'IA donne une direction haussière avec une confiance de 76 %, recommande une entrée immédiate à l'ouverture dans la fourchette de prix 128 à 130, un effet de levier de 10x, un stop-loss à 5 %, un take-profit à 15 %, risque moyen.

Limites de la stratégie et avertissement sur les risques

Le problème principal que cette stratégie résout est, avant la cotation d'une nouvelle pièce, d'établir une compréhension systématique de cette pièce en remplacement d'une approche manuelle, et de transformer les conclusions en signaux d'entrée exploitables. Mais il faut bien reconnaître ses limites :

Les nouvelles pièces sont extrêmement volatiles, le stop-loss peut être déclenché dans la première minute suivant l'ouverture ; la qualité du jugement de l'IA dépend de l'exhaustivité des données, moins il y a de données avant cotation, plus le jugement est conservateur ; l'effet de levier amplifie les gains et les pertes, aucune stratégie ne peut garantir des profits constants.

Un bon contrôle de la taille des positions est la condition préalable la plus importante pour utiliser cette stratégie.

Ce système n'est actuellement qu'un point de départ. Le « new coin listing » est un domaine très profond, avec de nombreuses dimensions à optimiser : signaux, timing d'entrée, gestion de position. Si vous avez votre propre expérience et des idées dans ce domaine, n'hésitez pas à en discuter dans les commentaires — c'est en mutualisant les idées que l'on va plus loin. Toute stratégie comporte un risque de perte ; avant de l'utiliser, il est impératif de perfectionner la logique de la stratégie en fonction de votre situation personnelle.

Code source de la stratégie : Stratégie IA intelligente pour les nouvelles cotations Binance