> ## Documentation Index
> Fetch the complete documentation index at: https://www.helius.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Comment diffuser les données Solana Pump AMM

> Apprenez à diffuser les données en direct de Solana Pump AMM à l'aide de LaserStream WebSocket. Surveillance basée sur les journaux disponible sur tous les plans avec reconnexion automatique.

## Utiliser LaserStream WebSocket

<p>
  [LaserStream WebSocket](/docs/fr/rpc/websocket) vous offre une intégration WebSocket simple et est disponible sur tous les plans Helius, ce qui en fait un choix pratique pour les développeurs. Cet exemple utilise la méthode `logsSubscribe` de Solana, vous recevez donc uniquement des messages de journal.
</p>

<Tip>
  LaserStream WebSocket est jusqu'à 200 ms plus rapide que l'implémentation standard de WebSocket basée sur Agave RPC.
</Tip>

### Comment ça fonctionne

Connectez-vous au [point de terminaison LaserStream WebSocket](https://www.helius.dev/docs/api-reference/endpoints), abonnez-vous aux journaux mentionnant le [programme Pump AMM](https://orbmarkets.io/address/pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA/history), et traitez les données de journal entrantes.

L'exemple ci-dessous inclut une logique de reconnexion automatique avec retards exponentiels.

## Exigences

<Card>
  <ul>
    <li><strong>Node.js ≥ 18</strong> (testé avec v20)</li>
    <li><strong>TypeScript ≥ 5</strong> si vous prévoyez d'exécuter les échantillons <code>.ts</code> avec <code>ts‑node</code></li>
    <li>N'importe quel <strong>plan Helius</strong> – fonctionne avec tous les niveaux de plan</li>
    <li>Une <strong>variable d'environnement</strong> nommée <code>HELIUS\_API\_KEY</code> qui stocke votre clé API</li>
  </ul>

  <Tip>
    Installez globalement les dépendances : <code>npm i -g typescript ts‑node</code>
  </Tip>
</Card>

## Mise en œuvre

<Steps>
  <Step title="Installer les dépendances">
    ```bash theme={"system"}
    npm install ws
    ```
  </Step>

  <Step title="Créer le client WebSocket">
    Créez un fichier nommé `standard-ws-pump.ts` avec le code suivant :

    ```ts theme={"system"}
    // standard-ws-pump.ts
    import WebSocket from 'ws';

    // Configuration
    const MAX_RETRIES = 5;
    const INITIAL_RETRY_DELAY = 1000; // 1 second
    let retryCount = 0;
    let retryTimeout: NodeJS.Timeout | null = null;
    let subscriptionId: number | null = null;

    // Create a WebSocket connection
    let ws: WebSocket;

    function connect() {
      ws = new WebSocket(`wss://mainnet.helius-rpc.com/?api-key=${process.env.HELIUS_API_KEY}`);

      // Function to send a request to the WebSocket server
      function sendRequest(ws: WebSocket): void {
        const request = {
          "jsonrpc": "2.0",
          "id": 1,
          "method": "logsSubscribe",
          "params": [
            {
              "mentions": ["pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA"]
            }
          ]
        };
        console.log('Sending subscription request:', JSON.stringify(request, null, 2));
        ws.send(JSON.stringify(request));
      }

      // Function to send a ping to the WebSocket server
      function startPing(ws: WebSocket): void {
        setInterval(() => {
          if (ws.readyState === WebSocket.OPEN) {
            ws.ping();
            console.log('Ping sent');
          }
        }, 30000); // Ping every 30 seconds
      }

      // Define WebSocket event handlers
      ws.on('open', function open() {
        console.log('WebSocket is open');
        retryCount = 0; // Reset retry count on successful connection
        sendRequest(ws); // Send a request once the WebSocket is open
        startPing(ws); // Start sending pings
      });

      ws.on('message', function incoming(data: WebSocket.Data) {
        const messageStr = data.toString('utf8');
        try {
          const messageObj = JSON.parse(messageStr);

          // Handle subscription confirmation
          if (messageObj.result && typeof messageObj.result === 'number') {
            subscriptionId = messageObj.result;
            console.log('Successfully subscribed with ID:', subscriptionId);
            return;
          }

          // Handle actual log data
          if (messageObj.params && messageObj.params.result) {
            const logData = messageObj.params.result;
            console.log('Received log data:', JSON.stringify(logData, null, 2));
            
            // Extract the transaction signature if available
            if (logData.signature) {
              console.log('Transaction signature:', logData.signature);
              // You can call getTransaction with this signature to get the full transaction details
            }
          } else {
            console.log('Received message:', JSON.stringify(messageObj, null, 2));
          }
        } catch (e) {
          console.error('Failed to parse JSON:', e);
        }
      });

      ws.on('error', function error(err: Error) {
        console.error('WebSocket error:', err);
      });

      ws.on('close', function close() {
        console.log('WebSocket is closed');
        if (subscriptionId) {
          console.log('Last subscription ID was:', subscriptionId);
        }
        reconnect();
      });
    }

    function reconnect() {
      if (retryCount >= MAX_RETRIES) {
        console.error('Max retry attempts reached. Please check your connection and try again.');
        return;
      }

      const delay = INITIAL_RETRY_DELAY * Math.pow(2, retryCount);
      console.log(`Attempting to reconnect in ${delay/1000} seconds... (Attempt ${retryCount + 1}/${MAX_RETRIES})`);

      retryTimeout = setTimeout(() => {
        retryCount++;
        connect();
      }, delay);
    }

    // Start the initial connection
    connect();

    // Cleanup function
    process.on('SIGINT', () => {
      if (retryTimeout) {
        clearTimeout(retryTimeout);
      }
      if (ws) {
        ws.close();
      }
      process.exit();
    });
    ```
  </Step>

  <Step title="Définir les variables d'environnement">
    Ajoutez votre clé API Helius comme variable d'environnement :

    ```bash theme={"system"}
    export HELIUS_API_KEY=your-helius-api-key
    ```

    Remplacez `your-helius-api-key` par votre clé API Helius réelle du tableau de bord.

    Si vous n'avez pas de clé API, [inscrivez-vous](https://dashboard.helius.dev/signup) ou demandez à votre agent d'en créer une par programmation avec [le Helius CLI](/docs/fr/agents/cli).
  </Step>

  <Step title="Exécuter l'application">
    Exécutez le script pour commencer à diffuser les données Pump AMM :

    ```bash theme={"system"}
    npx ts-node standard-ws-pump.ts
    ```

    Vous recevrez des messages de journal mentionnant le programme Pump AMM. Pour obtenir la transaction complète, appelez [`getTransaction`](/docs/fr/api-reference/rpc/http/gettransaction) avec la signature de l'entrée de journal.
  </Step>
</Steps>

## Principaux avantages

* **Accès universel** - Disponible sur tous les plans Helius, y compris le niveau gratuit
* **Léger** - Transfert de données minimal car seuls les journaux sont diffusés, pas de transactions complètes
* **Facile à implémenter** - Utilise le protocole WebSocket RPC standard de Solana
* **Faible barrière à l'entrée** - Parfait pour le prototypage et la surveillance initiale

## Obtenir les détails complets de la transaction

Étant donné que le WebSocket Standard ne fournit que des messages de journal, vous aurez besoin d'une étape supplémentaire pour obtenir des données complètes sur la transaction :

```ts theme={"system"}
// Example of how to fetch a full transaction from a log entry
async function fetchFullTransaction(signature: string) {
  const response = await fetch(`https://mainnet.helius-rpc.com/?api-key=${process.env.HELIUS_API_KEY}`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 'my-id',
      method: 'getTransaction',
      params: [
        signature,
        {
          encoding: 'jsonParsed',
          maxSupportedTransactionVersion: 1
        }
      ]
    })
  });
  
  const data = await response.json();
  return data.result;
}
```

## Problèmes courants et solutions

<AccordionGroup>
  <Accordion title="401 Non autorisé">
    Vérifiez que votre HELIUS\_API\_KEY est correcte.
  </Accordion>

  <Accordion title="Aucun journal reçu">
    Assurez-vous que l'adresse du programme Pump AMM est correcte et qu'il y a de l'activité sur le programme.
  </Accordion>

  <Accordion title="Connexion interrompue">
    Implémentez une logique de reconnexion plus robuste ou vérifiez la stabilité du réseau.
  </Accordion>
</AccordionGroup>