> ## 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.

# Déployez Votre Premier Programme Solana

> Amenez un programme Solana de la source à une transaction devnet en direct, avec le financement, le déploiement et les appels tous acheminés via votre Helius RPC.

export const DevnetFaucet = () => {
  const [apiKey, setApiKey] = useState('');
  const [address, setAddress] = useState('');
  const [loading, setLoading] = useState(false);
  const [result, setResult] = useState(null);
  const [error, setError] = useState(null);
  const handleAirdrop = async e => {
    e.preventDefault();
    setLoading(true);
    setError(null);
    setResult(null);
    try {
      const res = await fetch(`https://devnet.helius-rpc.com/?api-key=${apiKey}`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          jsonrpc: '2.0',
          id: 'faucet',
          method: 'requestAirdrop',
          params: [address, 1000000000]
        })
      });
      const json = await res.json();
      if (json.error) throw new Error(json.error.message || 'Airdrop failed');
      setResult(json.result);
    } catch (err) {
      setError(err.message || 'Airdrop failed. The devnet faucet is rate-limited, try again shortly.');
    } finally {
      setLoading(false);
    }
  };
  const btnClass = loading ? 'px-4 py-2 font-medium rounded-full bg-gray-300 dark:bg-gray-700 cursor-not-allowed' : 'px-4 py-2 font-medium rounded-full bg-primary hover:bg-primary/80 text-white';
  return <div className="p-4 border dark:border-zinc-950/80 rounded-xl bg-white dark:bg-zinc-950/80 shadow-sm">
      <form onSubmit={handleAirdrop} className="space-y-4">
        <div>
          <label className="block text-sm text-zinc-950/70 dark:text-white/70 mb-1">Your API Key</label>
          <input type="text" value={apiKey} onChange={e => setApiKey(e.target.value)} placeholder="Enter your API key" className="w-full p-2 border rounded dark:bg-zinc-900 dark:border-zinc-700" required />
        </div>
        <div>
          <label className="block text-sm text-zinc-950/70 dark:text-white/70 mb-1">Devnet Wallet Address</label>
          <input type="text" value={address} onChange={e => setAddress(e.target.value)} placeholder="Your devnet address" className="w-full p-2 border rounded dark:bg-zinc-900 dark:border-zinc-700" required />
        </div>
        <button type="submit" disabled={loading} className={btnClass}>
          {loading ? 'Requesting...' : 'Request 1 Devnet SOL'}
        </button>
      </form>
      <p className="mt-3 text-xs text-zinc-500 dark:text-zinc-400">
        Your API key is used only in your browser to call Helius directly. It is never sent anywhere else.
      </p>
      {error ? <div className="mt-4 p-3 bg-red-100 dark:bg-red-900/30 border border-red-200 dark:border-red-800 rounded text-red-700 dark:text-red-300">
          <strong>Error:</strong> {error}
        </div> : null}
      {result ? <div className="mt-4 p-3 bg-green-100 dark:bg-green-900/30 border border-green-200 dark:border-green-800 rounded text-green-700 dark:text-green-300 text-sm break-all">
          <strong>Airdrop sent!</strong> Signature: {result}
        </div> : null}
    </div>;
};

Dans ce guide, vous déploierez un programme réel sur devnet et l'invoquerez, avec l'ensemble du flux s'exécutant sur l'infrastructure Helius. Vous financerez un portefeuille avec [`requestAirdrop`](/docs/fr/api-reference/rpc/http/requestairdrop), déploierez un programme d'exemple préconstruit, puis l'appellerez avec [`sendTransaction`](/docs/fr/api-reference/rpc/http/sendtransaction) et confirmerez le résultat avec [`getSignatureStatuses`](/docs/fr/api-reference/rpc/http/getsignaturestatuses). Utiliser un programme prêt à l'emploi permet de se concentrer sur la boucle de déploiement-et-invocation au lieu d'écrire en Rust.

<Info>
  **Prérequis :** le [Solana CLI](https://solana.com/docs/intro/installation) et [Rust](https://www.rust-lang.org/tools/install) (pour construire le programme), Node.js 18+ (pour l'invoquer), et une [clé API Helius](https://dashboard.helius.dev/api-keys). Devnet fonctionne sur chaque plan Helius.
</Info>

***

<Steps>
  <Step title="Pointer le Solana CLI vers votre Helius devnet RPC">
    Utilisez votre point de terminaison Helius pour chaque commande CLI, et créez un portefeuille si vous n'en avez pas :

    ```bash theme={"system"}
    solana config set --url https://devnet.helius-rpc.com/?api-key=YOUR_API_KEY
    solana-keygen new --no-bip39-passphrase   # skip if you already have a keypair
    solana address
    ```

    `solana address` imprime la clé publique de votre portefeuille, que vous financerez ensuite.
  </Step>

  <Step title="Obtenez devnet SOL">
    Le déploiement coûte un peu de SOL. Le SOL de devnet est gratuit et uniquement destiné aux tests, alors financez votre adresse avec le robinet ci-dessous ou depuis le CLI :

    ```bash theme={"system"}
    solana airdrop 1
    solana balance
    ```

    <DevnetFaucet />

    <Note>
      Les robinets devnet sont limités en débit, donc un airdrop peut échouer. Si c'est le cas, attendez un moment et réessayez, ou utilisez le [robinet web devnet officiel](https://faucet.solana.com/) de Solana en cas de besoin. Le déploiement du programme exemple ne nécessite qu'environ 1 SOL.
    </Note>
  </Step>

  <Step title="Clonez et construisez le programme exemple">
    Récupérez le programme "Hello, Solana!" depuis le dépôt [program-examples](https://github.com/solana-developers/program-examples) officiel de Solana. Il enregistre simplement un message de salutation lorsqu'il est invoqué, ce qui est à peu près le plus petit programme qui prouve que la boucle complète fonctionne.

    ```bash theme={"system"}
    git clone https://github.com/solana-developers/program-examples.git
    cd program-examples
    cargo build-sbf --manifest-path basics/hello-solana/native/program/Cargo.toml
    ```

    `program-examples` est un espace de travail Cargo, donc `cargo build-sbf` compile le programme à `target/deploy/hello_solana_program.so` à la racine du dépôt (pas dans le dossier du programme). Restez dans le répertoire `program-examples` pour l'étape suivante.
  </Step>

  <Step title="Déployez sur devnet via Helius">
    ```bash theme={"system"}
    solana program deploy target/deploy/hello_solana_program.so
    ```

    Le CLI soumet la transaction de déploiement via votre Helius RPC et imprime l'**ID du Programme**. Copiez-le, car vous invoquerez ce programme ensuite.

    ```
    Program Id: 4Nd1mYQ...your program id...
    ```
  </Step>

  <Step title="Invoquez le programme avec sendTransaction">
    Dans un nouveau dossier, configurez un petit client TypeScript qui construit une transaction, l'envoie, et la confirme.

    ```bash theme={"system"}
    mkdir invoke-client && cd invoke-client
    npm init -y
    npm install @solana/web3.js
    ```

    ```typescript invoke.ts [expandable] theme={"system"}
    import {
      Connection,
      Keypair,
      PublicKey,
      Transaction,
      TransactionInstruction,
    } from "@solana/web3.js";
    import { readFileSync } from "fs";
    import { homedir } from "os";

    const RPC = "https://devnet.helius-rpc.com/?api-key=YOUR_API_KEY";
    const PROGRAM_ID = new PublicKey("YOUR_PROGRAM_ID"); // from the deploy step

    async function main() {
      const connection = new Connection(RPC, "confirmed");

      // Load the same keypair the CLI created and funded.
      const secret = JSON.parse(
        readFileSync(`${homedir()}/.config/solana/id.json`, "utf8")
      );
      const payer = Keypair.fromSecretKey(Uint8Array.from(secret));

      // The hello-solana program takes no accounts and no data. It just logs.
      const instruction = new TransactionInstruction({
        keys: [],
        programId: PROGRAM_ID,
        data: Buffer.alloc(0),
      });

      const tx = new Transaction().add(instruction);
      const { blockhash } = await connection.getLatestBlockhash();
      tx.recentBlockhash = blockhash;
      tx.feePayer = payer.publicKey;
      tx.sign(payer);

      // sendTransaction submits the signed transaction to the cluster via Helius.
      const signature = await connection.sendRawTransaction(tx.serialize());
      console.log("Sent:", signature);

      // Poll getSignatureStatuses until the transaction is confirmed.
      for (let i = 0; i < 30; i++) {
        const { value } = await connection.getSignatureStatuses([signature]);
        const status = value[0];
        if (status?.confirmationStatus === "confirmed" || status?.confirmationStatus === "finalized") {
          if (status.err) throw new Error(`Failed: ${JSON.stringify(status.err)}`);
          console.log("Confirmed! View it on Solana Explorer:");
          console.log(`https://explorer.solana.com/tx/${signature}?cluster=devnet`);
          return;
        }
        await new Promise((r) => setTimeout(r, 1000));
      }
      throw new Error("Timed out waiting for confirmation");
    }

    main().catch(console.error);
    ```

    Remplacez `YOUR_API_KEY` et `YOUR_PROGRAM_ID`, puis exécutez-le :

    ```bash theme={"system"}
    npx tsx invoke.ts
    ```

    Vous obtiendrez une signature et un lien Explorer. Ouvrez le lien et développez les **Journal des Instructions du Programme** pour voir la salutation `Hello, Solana!` du programme.
  </Step>
</Steps>

## Ce qui se passe

### Tout est acheminé via votre Helius RPC

`solana config set --url` pointe chaque commande CLI (airdrop, déploiement, et les vérifications de solde) vers votre point de terminaison Helius devnet. Le client TypeScript utilise le même point de terminaison, donc l'ensemble du flux s'exécute sur l'infrastructure Helius.

### La boucle d'invocation : envoyer, puis confirmer

`sendRawTransaction` appelle la méthode RPC [`sendTransaction`](/docs/fr/api-reference/rpc/http/sendtransaction) en arrière-plan et retourne une signature immédiatement, avant que le réseau ait traité la transaction. C'est pourquoi vous polluez [`getSignatureStatuses`](/docs/fr/api-reference/rpc/http/getsignaturestatuses) jusqu'à ce que `confirmationStatus` atteigne `confirmed`, vérifiant `err` pour détecter les échecs. Ce modèle envoyer-puis-confirmer est la base de chaque transaction Solana que vous soumettrez.

## Prochaines étapes

<CardGroup cols={2}>
  <Card title="Comment obtenir Devnet SOL" icon="faucet-drip" href="/docs/fr/rpc/devnet-sol">
    Toutes les manières de financer un portefeuille devnet, plus des conseils sur les limites de débit.
  </Card>

  <Card title="sendTransaction" icon="paper-plane" href="/docs/fr/api-reference/rpc/http/sendtransaction">
    Tous les paramètres, y compris skipPreflight, preflightCommitment, et retries.
  </Card>

  <Card title="Lander des transactions de manière fiable" icon="rocket" href="/docs/fr/api-reference/sender/sendtransaction">
    Lorsque vous passez au mainnet, utilisez Sender pour un atterrissage à ultra faible latence.
  </Card>

  <Card title="Construire un tracker de portefeuille" icon="wallet" href="/docs/fr/quickstart/portfolio-tracker">
    Autre piste : tirer les tokens, NFTs, et SOL de n'importe quel portefeuille, avec un flux d'activité en direct.
  </Card>
</CardGroup>