# Préparer l’environnement

> La chaîne d’outils que fixe le dépôt, les deux espaces de travail qu’il contient, le fichier de cérémonie dont a besoin la génération de preuves, et la machine qu’exige chaque étape.

Apogee v1.0.0 est un dépôt Rust. Il n’y a rien à installer hormis `rustup` : le dépôt fixe sa chaîne d’outils, et la chaîne d’outils comprend la cible des programmes invités. Écrire, compiler, exécuter et profiler un programme invité ne demande rien de plus. La génération de preuves ajoute un gros fichier et une machine dotée d’une mémoire à l’avenant.

## La chaîne d’outils

`rust-toolchain.toml`, à la racine du dépôt, fixe Rust stable **1.96.1** avec `rustfmt`, `clippy` et `llvm-tools`, ainsi que la cible **`riscv32imac-unknown-none-elf`**, dont `core` et `alloc` sont livrés précompilés. rustup l’applique dans chaque répertoire sous la racine et l’installe à la première utilisation.

```sh
cd apogee-vm
rustup show active-toolchain     # 1.96.1, overridden by rust-toolchain.toml
cargo --version
```

Aucune version nightly ni aucune fonctionnalité instable n’est utilisée nulle part. `llvm-tools` fournit les `llvm-objdump` et `llvm-nm` correspondant au LLVM du compilateur, que le dépôt utilise pour ses listages de désassemblage versionnés et dont vous pouvez vous servir pour lire le code de votre programme invité.

## Deux espaces de travail

La copie de travail contient deux espaces de travail Cargo, et cette séparation compte :

| Espace de travail | Racine | Compile pour | Contient |
| --- | --- | --- | --- |
| L’espace de travail racine | `Cargo.toml` | votre hôte | le prouveur, le vérificateur, le SDK hôte, les outils, tout ce qui se trouve dans `crates/` et `tools/` |
| L’espace de travail des programmes invités | `guests/Cargo.toml` | `riscv32imac-unknown-none-elf` | tous les programmes invités, et un répertoire `guests/target` qui lui est propre |

Les programmes invités sont tenus à part parce que chaque membre se compile pour la cible des programmes invités et lie un `#[panic_handler]`; `cargo test --workspace` à la racine ne doit jamais les atteindre. L’espace de travail des programmes invités contient aussi ce dont un programme invité a besoin pour être compilé correctement, si bien que vous n’avez jamais à le taper :

- `guests/.cargo/config.toml` fixe la cible et passe à l’éditeur de liens `-T crates/guest-sdk/link.ld`, la carte mémoire, et `--no-relax`, parce que la relaxation déplacerait des adresses que lie l’identité du programme.
- `guests/Cargo.toml` fixe les deux profils de compilation à la même sémantique, vérifications de dépassement comprises ([Compiler et inspecter](https://apogee.gweb3networks.com/docs/launch/build#profiles)).
- Sa section `[patch.crates-io]` redirige `k256`, `ark-ff` et `revm-precompile` vers des copies embarquées qui appellent les délégations d’Apogee ([Délégations](https://apogee.gweb3networks.com/docs/launch/delegations#vendored)).

> [!TIP]
> Ouvrez `guests/` comme un dossier distinct dans votre éditeur. rust-analyzer lit alors le `.cargo/config.toml` de cet espace de travail et vérifie le code des programmes invités pour la cible des programmes invités plutôt que pour votre hôte.

## Le fichier de cérémonie

Chaque engagement que produit Apogee repose sur les puissances d’un `τ` secret issu d’une cérémonie publique : les **puissances de tau perpétuelles de PSE, contribution 80**. Un seul fichier sert à tous les usages :

```text
assets/ptau/ppot_0080_24.ptau        19.3 GB, 2^24 powers; assets/ptau/ is gitignored
```

Il vous le faut pour calculer une identité de programme, pour construire de vraies clés et pour prouver. Il ne vous le faut pas pour compiler, exécuter ou profiler un programme invité, ni pour lancer les tests de l’espace de travail, qui prouvent sur leur propre mise en place jouet.

Les fichiers de la cérémonie de PSE sont tirés d’une même transcription, si bien que tout fichier de puissance 24 ou plus convient. Le `powersOfTau28_hez_final_*.ptau` de Hermez provient d’une autre cérémonie, avec un autre `τ` : le lecteur l’ingère tout aussi facilement, et chaque engagement, chaque clé et chaque identité calculés sur ce fichier en sortent différents. Pour confirmer que vous détenez la bonne cérémonie, voici son `[τ]_1`, en hexadécimal de son encodage canonique `x ‖ y` :

```text
9bbb31bedc304e081e2aada4b56c2217e0e94ee16874e3517d14bef5dcec3a16
317ff1589e53513fa333591b318e8f1e55ef7c37d92beb6d9a61d770a2f39506
```

La [page SRS](https://apogee.gweb3networks.com/docs/auditors/spec/srs) de la spécification énonce exactement ce que vérifie le lecteur et ce qu’il tient pour acquis.

## La machine

Compiler et exécuter, c’est un travail de portable. La génération de preuves est limitée par la mémoire, et la mémoire qu’elle consomme suit les shards prouvés simultanément, pas la longueur de l’exécution.

| Étape | Besoins |
| --- | --- |
| Compiler un programme invité, l’exécuter, le profiler, exporter et inspecter son image | N’importe quel portable récent; quelques secondes |
| Calculer une identité de programme (`artifact-dump tables --ptau`) | Le fichier de cérémonie; environ 25 s sur un portable à 18 cœurs aux hauteurs par défaut |
| Prouver un petit programme invité à des hauteurs de `2^20` | Des dizaines de GiB. Un shard `2^20` de la famille d’instructions la plus large occupe environ 8,4 GiB d’éléments du corps dans sa passe avant, et chaque shard en cours de traitement occupe les siens |
| Prouver un bloc Ethereum complet | Le bloc mesuré a culminé à 174 GiB sur une machine à 32 vCPU et 247,7 GiB |

La page sur la génération de preuves explique comment les hauteurs et le nombre de shards en cours de traitement arbitrent entre mémoire et temps : [Prouver et vérifier](https://apogee.gweb3networks.com/docs/launch/prove#heights).

## Vérifier votre copie de travail

Ce qu’exécute la CI, le tout sans le fichier de cérémonie :

```sh
cargo fmt --all -- --check
cargo clippy --workspace --all-targets -- -D warnings
cargo test --workspace
cargo run -p kat-gen && git diff --exit-code      # committed fixtures regenerate identically
(cd guests && cargo clippy --bins -- -D warnings)
```

Les suites qui prouvent de vrais shards sont marquées `#[ignore]`, parce que chacune nécessite des dizaines de GiB. Lancez-en une par son nom quand vous voulez voir une preuve produite et refusée sur votre propre machine :

```sh
cargo test --release -p prover --test acceptance -- --include-ignored --test-threads=1
```

Ensuite : [écrivez un programme invité](https://apogee.gweb3networks.com/docs/launch/write), ou parcourez une fois la boucle complète dans le [Démarrage rapide](https://apogee.gweb3networks.com/docs/launch/quickstart).