0.5.1-pre.004

2026-08-09 22:52:37 +02:00
parent 6151bb25e7
commit ec07ddbd80
53 changed files with 989 additions and 886 deletions
--- a/docs/DEVNET_EXECUTION_GUIDE.md
+++ b/docs/DEVNET_EXECUTION_GUIDE.md
@@ -1,5 +1,5 @@
 <!-- file: docs/DEVNET_EXECUTION_GUIDE.md -->
-<!-- version: 25 -->
+<!-- version: 26 -->

 # Guide d’exécution Devnet

@@ -21,8 +21,8 @@ Les commandes réutilisables sont centralisées en section 4. Chaque scénario r

 ## 2. Préconditions

- `.env` contient `KB_POSTGRES_DEVNET_URL` et les secrets de transport requis ;
- `KB_POSTGRES_DEVNET_URL`, `KB_POSTGRES_MAINNET_URL` et `KB_POSTGRES_TEST_URL` désignent des bases distinctes ;
+- `.env` contient `KS_SECRET_POSTGRES_DEVNET_URL` et les secrets de transport requis ;
+- `KS_SECRET_POSTGRES_DEVNET_URL`, `KS_SECRET_POSTGRES_MAINNET_URL` et `KS_SECRET_POSTGRES_TEST_URL` désignent des bases distinctes ;
 - le profil sélectionné est Devnet et autorise explicitement l’envoi Devnet ;
 - l’envoi Mainnet reste désactivé ;
 - les plafonds de frais, de dépense et de rent sont contrôlés ;
@@ -44,7 +44,7 @@ Ce terminal reste occupé par `cargo tauri dev` pendant toute la campagne. Il af

 Ce terminal reste disponible pour les commandes Solana, PostgreSQL, balances, confirmations et captures avec `tee`.

-Les commandes `C01` à `C05` doivent être exécutées dans le terminal B. Le terminal A doit exécuter `T01`, puis rester ouvert. Avant chaque scénario, le terminal B doit définir `KB_DEVNET_SCENARIO` avant d’appeler `C06`.
+Les commandes `C01` à `C05` doivent être exécutées dans le terminal B. Le terminal A doit exécuter `T01`, puis rester ouvert. Avant chaque scénario, le terminal B doit définir `KS_DEVNET_SCENARIO` avant d’appeler `C06`.

 ## 4. Commandes communes

@@ -100,13 +100,13 @@ Arrêter avec `Ctrl+C`, puis relancer `T01`.
 ### C01 — Initialiser l’environnement de validation

 ```bash
-cd ~/Projects/khadhroony-bot3 && set -o pipefail && export KB_DEVNET_PROFILE="local_devnet" && export KB_DEVNET_RPC_URL="https://api.devnet.solana.com" && export KB_DEVNET_VALIDATION_DIR="/tmp/devnet-validation/current" && export KB_DEVNET_WALLET="$PWD/wallets/temporary/local_devnet/local-devnet-operator.json" && mkdir -p "$KB_DEVNET_VALIDATION_DIR" && printf 'Profil     : %s\n' "$KB_DEVNET_PROFILE" && printf 'RPC Devnet : %s\n' "$KB_DEVNET_RPC_URL" && printf 'Preuves    : %s\n' "$KB_DEVNET_VALIDATION_DIR" && printf 'Wallet     : %s\n' "$KB_DEVNET_WALLET";
+cd ~/Projects/khadhroony-bot3 && set -o pipefail && export KS_DEVNET_PROFILE="local_devnet" && export KS_DEVNET_RPC_URL="https://api.devnet.solana.com" && export KS_DEVNET_VALIDATION_DIR="/tmp/devnet-validation/current" && export KS_DEVNET_WALLET="$PWD/wallets/temporary/local_devnet/local-devnet-operator.json" && mkdir -p "$KS_DEVNET_VALIDATION_DIR" && printf 'Profil     : %s\n' "$KS_DEVNET_PROFILE" && printf 'RPC Devnet : %s\n' "$KS_DEVNET_RPC_URL" && printf 'Preuves    : %s\n' "$KS_DEVNET_VALIDATION_DIR" && printf 'Wallet     : %s\n' "$KS_DEVNET_WALLET";
 ```

 ### C02 — Capturer les versions CLI

 ```bash
-command -v solana && command -v solana-keygen && command -v spl-token && { date --iso-8601=seconds; solana --version; solana-keygen --version; spl-token --version; } | tee "$KB_DEVNET_VALIDATION_DIR/00-cli-versions.txt";
+command -v solana && command -v solana-keygen && command -v spl-token && { date --iso-8601=seconds; solana --version; solana-keygen --version; spl-token --version; } | tee "$KS_DEVNET_VALIDATION_DIR/00-cli-versions.txt";
 ```

 Chaque campagne doit capturer les versions exactes des outils externes qu’elle utilise. Les fixtures Rust natives ne doivent pas dépendre implicitement de la configuration globale d’une CLI.
@@ -114,7 +114,7 @@ Chaque campagne doit capturer les versions exactes des outils externes qu’elle
 ### C03 — Vérifier l’identité du réseau

 ```bash
-solana config set --url "$KB_DEVNET_RPC_URL" && { date --iso-8601=seconds; solana config get; solana cluster-version --url "$KB_DEVNET_RPC_URL"; solana genesis-hash --url "$KB_DEVNET_RPC_URL";     solana epoch-info --url "$KB_DEVNET_RPC_URL"; } | tee "$KB_DEVNET_VALIDATION_DIR/01-devnet-network.txt";
+solana config set --url "$KS_DEVNET_RPC_URL" && { date --iso-8601=seconds; solana config get; solana cluster-version --url "$KS_DEVNET_RPC_URL"; solana genesis-hash --url "$KS_DEVNET_RPC_URL";     solana epoch-info --url "$KS_DEVNET_RPC_URL"; } | tee "$KS_DEVNET_VALIDATION_DIR/01-devnet-network.txt";
 ```

 Le genesis hash Devnet attendu est :
@@ -126,37 +126,37 @@ EtWTRABZaYq6iMfeYKouRu166VU2xqa1wcaWoxPkrZBG
 ### C04 — Vérifier le wallet opérateur

 ```bash
-test -f "$KB_DEVNET_WALLET" && chmod 600 "$KB_DEVNET_WALLET" && export KB_DEVNET_WALLET_PUBKEY="$(solana-keygen pubkey "$KB_DEVNET_WALLET")" && { date --iso-8601=seconds; printf 'wallet_path=%s\n' "$KB_DEVNET_WALLET"; printf 'wallet_pubkey=%s\n' "$KB_DEVNET_WALLET_PUBKEY"; solana balance  "$KB_DEVNET_WALLET_PUBKEY" --url "$KB_DEVNET_RPC_URL" --commitment confirmed; } | tee "$KB_DEVNET_VALIDATION_DIR/02-wallet.txt"
+test -f "$KS_DEVNET_WALLET" && chmod 600 "$KS_DEVNET_WALLET" && export KS_PUBLIC_DEVNET_WALLET_ADDRESS="$(solana-keygen pubkey "$KS_DEVNET_WALLET")" && { date --iso-8601=seconds; printf 'wallet_path=%s\n' "$KS_DEVNET_WALLET"; printf 'wallet_pubkey=%s\n' "$KS_PUBLIC_DEVNET_WALLET_ADDRESS"; solana balance  "$KS_PUBLIC_DEVNET_WALLET_ADDRESS" --url "$KS_DEVNET_RPC_URL" --commitment confirmed; } | tee "$KS_DEVNET_VALIDATION_DIR/02-wallet.txt"
 ```

 ### C05 — Recréer la base Devnet

-Cette commande est destructive. Elle ne doit viser que `KB_POSTGRES_DEVNET_URL`. Elle supprime toutes les données et tous les objets du schéma `public`, puis laisse l’application recréer son schéma lors de l’ouverture d’une fenêtre Devnet.
+Cette commande est destructive. Elle ne doit viser que `KS_SECRET_POSTGRES_DEVNET_URL`. Elle supprime toutes les données et tous les objets du schéma `public`, puis laisse l’application recréer son schéma lors de l’ouverture d’une fenêtre Devnet.

 ```bash
-test -n "$KB_POSTGRES_DEVNET_URL" && printf '%s\n' "$KB_POSTGRES_DEVNET_URL" && export KB_CONFIRM_DEVNET_DATABASE_RESET="YES_RESET_SOLANA_DEVNET" && test "$KB_CONFIRM_DEVNET_DATABASE_RESET" = "YES_RESET_SOLANA_DEVNET" && psql "$KB_POSTGRES_DEVNET_URL" -v ON_ERROR_STOP=1 -c 'DROP SCHEMA public CASCADE; CREATE SCHEMA public;'
+test -n "$KS_SECRET_POSTGRES_DEVNET_URL" && printf 'database_url=<configured>\n' && export KS_CONFIRM_DEVNET_DATABASE_RESET="YES_RESET_SOLANA_DEVNET" && test "$KS_CONFIRM_DEVNET_DATABASE_RESET" = "YES_RESET_SOLANA_DEVNET" && psql "$KS_SECRET_POSTGRES_DEVNET_URL" -v ON_ERROR_STOP=1 -c 'DROP SCHEMA public CASCADE; CREATE SCHEMA public;'
 ```

 Après ouverture d’une fenêtre Devnet, contrôler les tables :

 ```bash
-psql "$KB_POSTGRES_DEVNET_URL" -v ON_ERROR_STOP=1 -c "SELECT schemaname, tablename FROM pg_tables WHERE schemaname = 'public' ORDER BY tablename;" | tee "$KB_DEVNET_VALIDATION_DIR/03-devnet-schema.txt"
+psql "$KS_SECRET_POSTGRES_DEVNET_URL" -v ON_ERROR_STOP=1 -c "SELECT schemaname, tablename FROM pg_tables WHERE schemaname = 'public' ORDER BY tablename;" | tee "$KS_DEVNET_VALIDATION_DIR/03-devnet-schema.txt"
 ```

 ### C06 — Capturer le solde avant scénario

-Définir `KB_DEVNET_SCENARIO` avant l’appel.
+Définir `KS_DEVNET_SCENARIO` avant l’appel.

 ```bash
-test -n "${KB_DEVNET_SCENARIO:-}" && test -n "${KB_DEVNET_WALLET_PUBKEY:-}" && test -n "${KB_DEVNET_RPC_URL:-}" && test -n "${KB_DEVNET_VALIDATION_DIR:-}" && { date --iso-8601=seconds; printf 'scenario=%s\nwallet=%s\n' "$KB_DEVNET_SCENARIO" "$KB_DEVNET_WALLET_PUBKEY"; solana balance "$KB_DEVNET_WALLET_PUBKEY" --url "$KB_DEVNET_RPC_URL" --commitment confirmed; } | tee "$KB_DEVNET_VALIDATION_DIR/${KB_DEVNET_SCENARIO}-wallet-before.txt"
+test -n "${KS_DEVNET_SCENARIO:-}" && test -n "${KS_PUBLIC_DEVNET_WALLET_ADDRESS:-}" && test -n "${KS_DEVNET_RPC_URL:-}" && test -n "${KS_DEVNET_VALIDATION_DIR:-}" && { date --iso-8601=seconds; printf 'scenario=%s\nwallet=%s\n' "$KS_DEVNET_SCENARIO" "$KS_PUBLIC_DEVNET_WALLET_ADDRESS"; solana balance "$KS_PUBLIC_DEVNET_WALLET_ADDRESS" --url "$KS_DEVNET_RPC_URL" --commitment confirmed; } | tee "$KS_DEVNET_VALIDATION_DIR/${KS_DEVNET_SCENARIO}-wallet-before.txt"
 ```

 ### C07 — Confirmer une signature et capturer le solde après scénario

-Définir `KB_DEVNET_SCENARIO` et `KB_DEVNET_SIGNATURE` avant l’appel.
+Définir `KS_DEVNET_SCENARIO` et `KS_DEVNET_SIGNATURE` avant l’appel.

 ```bash
-test -n "${KB_DEVNET_SCENARIO:-}" && test -n "${KB_DEVNET_SIGNATURE:-}" && test -n "${KB_DEVNET_WALLET_PUBKEY:-}" && test -n "${KB_DEVNET_RPC_URL:-}" && test -n "${KB_DEVNET_VALIDATION_DIR:-}" && { date --iso-8601=seconds; printf 'scenario=%s\nsignature=%s\n' "$KB_DEVNET_SCENARIO" "$KB_DEVNET_SIGNATURE"; solana confirm "$KB_DEVNET_SIGNATURE" --url "$KB_DEVNET_RPC_URL" --commitment finalized --verbose; solana balance "$KB_DEVNET_WALLET_PUBKEY" --url "$KB_DEVNET_RPC_URL" --commitment confirmed; } | tee "$KB_DEVNET_VALIDATION_DIR/${KB_DEVNET_SCENARIO}-confirmation.txt"
+test -n "${KS_DEVNET_SCENARIO:-}" && test -n "${KS_DEVNET_SIGNATURE:-}" && test -n "${KS_PUBLIC_DEVNET_WALLET_ADDRESS:-}" && test -n "${KS_DEVNET_RPC_URL:-}" && test -n "${KS_DEVNET_VALIDATION_DIR:-}" && { date --iso-8601=seconds; printf 'scenario=%s\nsignature=%s\n' "$KS_DEVNET_SCENARIO" "$KS_DEVNET_SIGNATURE"; solana confirm "$KS_DEVNET_SIGNATURE" --url "$KS_DEVNET_RPC_URL" --commitment finalized --verbose; solana balance "$KS_PUBLIC_DEVNET_WALLET_ADDRESS" --url "$KS_DEVNET_RPC_URL" --commitment confirmed; } | tee "$KS_DEVNET_VALIDATION_DIR/${KS_DEVNET_SCENARIO}-confirmation.txt"
 ```

 ### C08 — Préparer un mint SPL Token classique pour ATA
@@ -168,11 +168,11 @@ L’option `--silent` est obligatoire afin que la phrase de récupération ne so
 La commande est idempotente au niveau du guide : si le compte du mint existe déjà sur Devnet, elle le réutilise.

 ```bash
-export KB_SPL_TOKEN_PROGRAM_ID="TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" && export KB_DEVNET_CLASSIC_MINT_KEYPAIR="$PWD/wallets/temporary/local_devnet/mints/ata-classic-mint.json" && mkdir -p "$(dirname "$KB_DEVNET_CLASSIC_MINT_KEYPAIR")" && { test -f "$KB_DEVNET_CLASSIC_MINT_KEYPAIR" || solana-keygen new --no-bip39-passphrase --force --silent --outfile "$KB_DEVNET_CLASSIC_MINT_KEYPAIR"; }
+export KS_PUBLIC_SPL_TOKEN_PROGRAM_ID="TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" && export KS_DEVNET_CLASSIC_MINT_KEYPAIR="$PWD/wallets/temporary/local_devnet/mints/ata-classic-mint.json" && mkdir -p "$(dirname "$KS_DEVNET_CLASSIC_MINT_KEYPAIR")" && { test -f "$KS_DEVNET_CLASSIC_MINT_KEYPAIR" || solana-keygen new --no-bip39-passphrase --force --silent --outfile "$KS_DEVNET_CLASSIC_MINT_KEYPAIR"; }
 ```

 ```bash
-export KB_DEVNET_CLASSIC_MINT="$(solana-keygen pubkey "$KB_DEVNET_CLASSIC_MINT_KEYPAIR")" && { solana account "$KB_DEVNET_CLASSIC_MINT" --url "$KB_DEVNET_RPC_URL" --output json >/dev/null 2>&1 || spl-token --url "$KB_DEVNET_RPC_URL" --program-id "$KB_SPL_TOKEN_PROGRAM_ID" create-token "$KB_DEVNET_CLASSIC_MINT_KEYPAIR" --decimals 9; } && printf 'classic_mint=%s\n' "$KB_DEVNET_CLASSIC_MINT" | tee "$KB_DEVNET_VALIDATION_DIR/30a-spl-ata-classic-mint.txt"
+export KS_DEVNET_CLASSIC_MINT="$(solana-keygen pubkey "$KS_DEVNET_CLASSIC_MINT_KEYPAIR")" && { solana account "$KS_DEVNET_CLASSIC_MINT" --url "$KS_DEVNET_RPC_URL" --output json >/dev/null 2>&1 || spl-token --url "$KS_DEVNET_RPC_URL" --program-id "$KS_PUBLIC_SPL_TOKEN_PROGRAM_ID" create-token "$KS_DEVNET_CLASSIC_MINT_KEYPAIR" --decimals 9; } && printf 'classic_mint=%s\n' "$KS_DEVNET_CLASSIC_MINT" | tee "$KS_DEVNET_VALIDATION_DIR/30a-spl-ata-classic-mint.txt"
 ```

 ### C09 — Préparer un mint Token-2022 pour ATA
@@ -180,11 +180,11 @@ export KB_DEVNET_CLASSIC_MINT="$(solana-keygen pubkey "$KB_DEVNET_CLASSIC_MINT_K
 Cette commande crée uniquement un mint Token-2022 de test persistant, sans extension supplémentaire. Elle ne crée aucun ATA.

 ```bash
-export KB_SPL_TOKEN_2022_PROGRAM_ID="TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb" && export KB_DEVNET_TOKEN_2022_MINT_KEYPAIR="$PWD/wallets/temporary/local_devnet/mints/ata-token-2022-mint.json" && mkdir -p "$(dirname "$KB_DEVNET_TOKEN_2022_MINT_KEYPAIR")" && { test -f "$KB_DEVNET_TOKEN_2022_MINT_KEYPAIR" || solana-keygen new --no-bip39-passphrase --force --silent --outfile "$KB_DEVNET_TOKEN_2022_MINT_KEYPAIR"; }
+export KS_PUBLIC_SPL_TOKEN_2022_PROGRAM_ID="TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb" && export KS_DEVNET_TOKEN_2022_MINT_KEYPAIR="$PWD/wallets/temporary/local_devnet/mints/ata-token-2022-mint.json" && mkdir -p "$(dirname "$KS_DEVNET_TOKEN_2022_MINT_KEYPAIR")" && { test -f "$KS_DEVNET_TOKEN_2022_MINT_KEYPAIR" || solana-keygen new --no-bip39-passphrase --force --silent --outfile "$KS_DEVNET_TOKEN_2022_MINT_KEYPAIR"; }
 ```

 ```bash
-export KB_DEVNET_TOKEN_2022_MINT="$(solana-keygen pubkey "$KB_DEVNET_TOKEN_2022_MINT_KEYPAIR")" && { solana account "$KB_DEVNET_TOKEN_2022_MINT" --url "$KB_DEVNET_RPC_URL" --output json >/dev/null 2>&1 || spl-token --url "$KB_DEVNET_RPC_URL" --program-id "$KB_SPL_TOKEN_2022_PROGRAM_ID" create-token "$KB_DEVNET_TOKEN_2022_MINT_KEYPAIR" --decimals 9; } && printf 'token_2022_mint=%s\n' "$KB_DEVNET_TOKEN_2022_MINT" | tee "$KB_DEVNET_VALIDATION_DIR/30b-spl-ata-token-2022-mint.txt"
+export KS_PUBLIC_DEVNET_TOKEN_2022_MINT="$(solana-keygen pubkey "$KS_DEVNET_TOKEN_2022_MINT_KEYPAIR")" && { solana account "$KS_PUBLIC_DEVNET_TOKEN_2022_MINT" --url "$KS_DEVNET_RPC_URL" --output json >/dev/null 2>&1 || spl-token --url "$KS_DEVNET_RPC_URL" --program-id "$KS_PUBLIC_SPL_TOKEN_2022_PROGRAM_ID" create-token "$KS_DEVNET_TOKEN_2022_MINT_KEYPAIR" --decimals 9; } && printf 'token_2022_mint=%s\n' "$KS_PUBLIC_DEVNET_TOKEN_2022_MINT" | tee "$KS_DEVNET_VALIDATION_DIR/30b-spl-ata-token-2022-mint.txt"
 ```

 ### C10 — Préparer les comptes du scénario SPL Token classique
@@ -201,37 +201,37 @@ Cette préparation réutilise le mint créé par `C08` et l’ATA classique cré
 1. Dériver l’ATA source avec la syntaxe exigée par `spl-token-cli 5.5.0` :

 ```bash
-export KB_DEVNET_CLASSIC_SOURCE_ATA="$(spl-token --url "$KB_DEVNET_RPC_URL" --program-id "$KB_SPL_TOKEN_PROGRAM_ID" address --verbose --token "$KB_DEVNET_CLASSIC_MINT" --owner "$KB_DEVNET_WALLET_PUBKEY" | awk -F': ' '/Associated token address/ {print $2}')" && test -n "$KB_DEVNET_CLASSIC_SOURCE_ATA" && printf 'source_ata=%s\n' "$KB_DEVNET_CLASSIC_SOURCE_ATA"
+export KS_DEVNET_CLASSIC_SOURCE_ATA="$(spl-token --url "$KS_DEVNET_RPC_URL" --program-id "$KS_PUBLIC_SPL_TOKEN_PROGRAM_ID" address --verbose --token "$KS_DEVNET_CLASSIC_MINT" --owner "$KS_PUBLIC_DEVNET_WALLET_ADDRESS" | awk -F': ' '/Associated token address/ {print $2}')" && test -n "$KS_DEVNET_CLASSIC_SOURCE_ATA" && printf 'source_ata=%s\n' "$KS_DEVNET_CLASSIC_SOURCE_ATA"
 ```

 2. Préparer un owner destinataire persistant :

 ```bash
-export KB_DEVNET_CLASSIC_RECIPIENT_KEYPAIR="$PWD/wallets/temporary/local_devnet/recipients/spl-token-transfer-recipient.json" && mkdir -p "$(dirname "$KB_DEVNET_CLASSIC_RECIPIENT_KEYPAIR")" && { test -f "$KB_DEVNET_CLASSIC_RECIPIENT_KEYPAIR" || solana-keygen new --no-bip39-passphrase --force --silent --outfile "$KB_DEVNET_CLASSIC_RECIPIENT_KEYPAIR"; } && export KB_DEVNET_CLASSIC_RECIPIENT="$(solana-keygen pubkey "$KB_DEVNET_CLASSIC_RECIPIENT_KEYPAIR")"
+export KS_DEVNET_CLASSIC_RECIPIENT_KEYPAIR="$PWD/wallets/temporary/local_devnet/recipients/spl-token-transfer-recipient.json" && mkdir -p "$(dirname "$KS_DEVNET_CLASSIC_RECIPIENT_KEYPAIR")" && { test -f "$KS_DEVNET_CLASSIC_RECIPIENT_KEYPAIR" || solana-keygen new --no-bip39-passphrase --force --silent --outfile "$KS_DEVNET_CLASSIC_RECIPIENT_KEYPAIR"; } && export KS_DEVNET_CLASSIC_RECIPIENT="$(solana-keygen pubkey "$KS_DEVNET_CLASSIC_RECIPIENT_KEYPAIR")"
 ```

 3. Dériver puis créer l’ATA destination si elle n’existe pas :

 ```bash
-export KB_DEVNET_CLASSIC_DESTINATION_ATA="$(spl-token --url "$KB_DEVNET_RPC_URL" --program-id "$KB_SPL_TOKEN_PROGRAM_ID" address --verbose --token "$KB_DEVNET_CLASSIC_MINT" --owner "$KB_DEVNET_CLASSIC_RECIPIENT" | awk -F': ' '/Associated token address/ {print $2}')" && test -n "$KB_DEVNET_CLASSIC_DESTINATION_ATA" && { solana account "$KB_DEVNET_CLASSIC_DESTINATION_ATA" --url "$KB_DEVNET_RPC_URL" --output json >/dev/null 2>&1 || spl-token --url "$KB_DEVNET_RPC_URL" --program-id "$KB_SPL_TOKEN_PROGRAM_ID" create-account "$KB_DEVNET_CLASSIC_MINT" --owner "$KB_DEVNET_CLASSIC_RECIPIENT" --fee-payer "$KB_DEVNET_WALLET"; }
+export KS_DEVNET_CLASSIC_DESTINATION_ATA="$(spl-token --url "$KS_DEVNET_RPC_URL" --program-id "$KS_PUBLIC_SPL_TOKEN_PROGRAM_ID" address --verbose --token "$KS_DEVNET_CLASSIC_MINT" --owner "$KS_DEVNET_CLASSIC_RECIPIENT" | awk -F': ' '/Associated token address/ {print $2}')" && test -n "$KS_DEVNET_CLASSIC_DESTINATION_ATA" && { solana account "$KS_DEVNET_CLASSIC_DESTINATION_ATA" --url "$KS_DEVNET_RPC_URL" --output json >/dev/null 2>&1 || spl-token --url "$KS_DEVNET_RPC_URL" --program-id "$KS_PUBLIC_SPL_TOKEN_PROGRAM_ID" create-account "$KS_DEVNET_CLASSIC_MINT" --owner "$KS_DEVNET_CLASSIC_RECIPIENT" --fee-payer "$KS_DEVNET_WALLET"; }
 ```

 4. Créditer le compte source. Cette commande ajoute `10` tokens à chaque exécution ; ne la relancer que si le solde source est insuffisant :

 ```bash
-spl-token --url "$KB_DEVNET_RPC_URL" --program-id "$KB_SPL_TOKEN_PROGRAM_ID" mint "$KB_DEVNET_CLASSIC_MINT" 10 "$KB_DEVNET_CLASSIC_SOURCE_ATA" --owner "$KB_DEVNET_WALLET" --fee-payer "$KB_DEVNET_WALLET"
+spl-token --url "$KS_DEVNET_RPC_URL" --program-id "$KS_PUBLIC_SPL_TOKEN_PROGRAM_ID" mint "$KS_DEVNET_CLASSIC_MINT" 10 "$KS_DEVNET_CLASSIC_SOURCE_ATA" --owner "$KS_DEVNET_WALLET" --fee-payer "$KS_DEVNET_WALLET"
 ```

 5. Afficher les comptes par leur adresse. Avec cette version du CLI, utiliser `display` plutôt que `account-info <adresse>`, car l’argument positionnel de `account-info` est interprété comme un mint :

 ```bash
-spl-token --url "$KB_DEVNET_RPC_URL" --program-id "$KB_SPL_TOKEN_PROGRAM_ID" display "$KB_DEVNET_CLASSIC_SOURCE_ATA" && spl-token --url "$KB_DEVNET_RPC_URL" --program-id "$KB_SPL_TOKEN_PROGRAM_ID" display "$KB_DEVNET_CLASSIC_DESTINATION_ATA"
+spl-token --url "$KS_DEVNET_RPC_URL" --program-id "$KS_PUBLIC_SPL_TOKEN_PROGRAM_ID" display "$KS_DEVNET_CLASSIC_SOURCE_ATA" && spl-token --url "$KS_DEVNET_RPC_URL" --program-id "$KS_PUBLIC_SPL_TOKEN_PROGRAM_ID" display "$KS_DEVNET_CLASSIC_DESTINATION_ATA"
 ```

 6. Capturer la fixture :

 ```bash
-{ printf 'mint=%s\n' "$KB_DEVNET_CLASSIC_MINT"; printf 'source=%s\n' "$KB_DEVNET_CLASSIC_SOURCE_ATA"; printf 'destination=%s\n' "$KB_DEVNET_CLASSIC_DESTINATION_ATA"; printf 'authority=%s\n' "$KB_DEVNET_WALLET_PUBKEY"; printf 'amount_raw=1000000000\n'; printf 'decimals=9\n'; } | tee "$KB_DEVNET_VALIDATION_DIR/40-spl-token-fixture.txt"
+{ printf 'mint=%s\n' "$KS_DEVNET_CLASSIC_MINT"; printf 'source=%s\n' "$KS_DEVNET_CLASSIC_SOURCE_ATA"; printf 'destination=%s\n' "$KS_DEVNET_CLASSIC_DESTINATION_ATA"; printf 'authority=%s\n' "$KS_PUBLIC_DEVNET_WALLET_ADDRESS"; printf 'amount_raw=1000000000\n'; printf 'decimals=9\n'; } | tee "$KS_DEVNET_VALIDATION_DIR/40-spl-token-fixture.txt"
 ```

 La création du compte destination par CLI est acceptable ici : `S03A` et `S03B` ont déjà validé l’executor ATA. `S04` doit isoler et valider l’executor SPL Token `TransferChecked`.
@@ -241,10 +241,10 @@ La création du compte destination par CLI est acceptable ici : `S03A` et `S03B`
 Le workspace fournit une commande idempotente qui prépare les comptes publics requis par les huit scénarios Token-2022 :

 ```bash
-cargo run -p ks-pipeline-demo-scenarios --bin ks-pipeline-demo-scenarios-cli -- prepare-token-2022-fixture --rpc-url "$KB_DEVNET_RPC_URL" --wallet "$KB_DEVNET_WALLET" --wallet-dir "$PWD/wallets/temporary/local_devnet" --decimals 9 | tee "$KB_DEVNET_VALIDATION_DIR/50-spl-token-2022-fixture-preparation.json"
+cargo run -p ks-pipeline-demo-scenarios --bin ks-pipeline-demo-scenarios-cli -- prepare-token-2022-fixture --rpc-url "$KS_DEVNET_RPC_URL" --wallet "$KS_DEVNET_WALLET" --wallet-dir "$PWD/wallets/temporary/local_devnet" --decimals 9 | tee "$KS_DEVNET_VALIDATION_DIR/50-spl-token-2022-fixture-preparation.json"
 ```

-Lorsque `--rpc-url` et `--wallet` sont omis, la commande utilise respectivement `KB_DEVNET_RPC_URL` et `KB_DEVNET_WALLET`. Lorsque `--wallet-dir` est omis, elle utilise le répertoire parent du wallet.
+Lorsque `--rpc-url` et `--wallet` sont omis, la commande utilise respectivement `KS_DEVNET_RPC_URL` et `KS_DEVNET_WALLET`. Lorsque `--wallet-dir` est omis, elle utilise le répertoire parent du wallet.

 La commande :

@@ -270,35 +270,35 @@ wallets/temporary/local_devnet/spl_token_2022_validation/fixture.env
 Elle définit :

 ```text
-TOKEN_2022_PROGRAM
-TOKEN_2022_MINT
-TOKEN_2022_SOURCE
-TOKEN_2022_DESTINATION
-TOKEN_2022_CLOSE_ACCOUNT
-TOKEN_2022_DELEGATE
-TOKEN_2022_AUTHORITY
-TOKEN_2022_FREEZE_AUTHORITY
-TOKEN_2022_DECIMALS
-TOKEN_2022_MINT_AMOUNT_RAW
-TOKEN_2022_TRANSFER_AMOUNT_RAW
-TOKEN_2022_APPROVE_AMOUNT_RAW
-TOKEN_2022_BURN_AMOUNT_RAW
-KB_DEVNET_WALLET_ADDRESS
+KS_PUBLIC_SPL_TOKEN_2022_PROGRAM_ID
+KS_PUBLIC_DEVNET_TOKEN_2022_MINT
+KS_PUBLIC_DEVNET_TOKEN_2022_SOURCE
+KS_PUBLIC_DEVNET_TOKEN_2022_DESTINATION
+KS_PUBLIC_DEVNET_TOKEN_2022_CLOSE_ACCOUNT
+KS_PUBLIC_DEVNET_TOKEN_2022_DELEGATE
+KS_PUBLIC_DEVNET_TOKEN_2022_AUTHORITY
+KS_PUBLIC_DEVNET_TOKEN_2022_FREEZE_AUTHORITY
+KS_PUBLIC_DEVNET_TOKEN_2022_DECIMALS
+KS_PUBLIC_DEVNET_TOKEN_2022_MINT_AMOUNT_RAW
+KS_PUBLIC_DEVNET_TOKEN_2022_TRANSFER_AMOUNT_RAW
+KS_PUBLIC_DEVNET_TOKEN_2022_APPROVE_AMOUNT_RAW
+KS_PUBLIC_DEVNET_TOKEN_2022_BURN_AMOUNT_RAW
+KS_PUBLIC_DEVNET_WALLET_ADDRESS
 ```

 Vérifier puis charger uniquement les valeurs publiques dans le terminal B :

 ```bash
-export KB_DEVNET_TOKEN_2022_FIXTURE="$PWD/wallets/temporary/local_devnet/spl_token_2022_validation/fixture.env" && test -f "$KB_DEVNET_TOKEN_2022_FIXTURE" && sed -n '/^export [A-Z0-9_]*=/p' "$KB_DEVNET_TOKEN_2022_FIXTURE" | sed 's/=.*$/=<défini>/' | tee "$KB_DEVNET_VALIDATION_DIR/50-spl-token-2022-fixture-keys.txt" && source "$KB_DEVNET_TOKEN_2022_FIXTURE"
+export KS_DEVNET_TOKEN_2022_FIXTURE="$PWD/wallets/temporary/local_devnet/spl_token_2022_validation/fixture.env" && test -f "$KS_DEVNET_TOKEN_2022_FIXTURE" && sed -n '/^export [A-Z0-9_]*=/p' "$KS_DEVNET_TOKEN_2022_FIXTURE" | sed 's/=.*$/=<défini>/' | tee "$KS_DEVNET_VALIDATION_DIR/50-spl-token-2022-fixture-keys.txt" && source "$KS_DEVNET_TOKEN_2022_FIXTURE"
 ```

 Afficher le mint et les trois comptes Token-2022 avec le Program ID explicite :

 ```bash
-spl-token --url "$KB_DEVNET_RPC_URL" --program-id "$TOKEN_2022_PROGRAM" display "$TOKEN_2022_MINT" && spl-token --url "$KB_DEVNET_RPC_URL" --program-id "$TOKEN_2022_PROGRAM" display "$TOKEN_2022_SOURCE" && spl-token --url "$KB_DEVNET_RPC_URL" --program-id "$TOKEN_2022_PROGRAM" display "$TOKEN_2022_DESTINATION" && spl-token --url "$KB_DEVNET_RPC_URL" --program-id "$TOKEN_2022_PROGRAM" display "$TOKEN_2022_CLOSE_ACCOUNT"
+spl-token --url "$KS_DEVNET_RPC_URL" --program-id "$KS_PUBLIC_SPL_TOKEN_2022_PROGRAM_ID" display "$KS_PUBLIC_DEVNET_TOKEN_2022_MINT" && spl-token --url "$KS_DEVNET_RPC_URL" --program-id "$KS_PUBLIC_SPL_TOKEN_2022_PROGRAM_ID" display "$KS_PUBLIC_DEVNET_TOKEN_2022_SOURCE" && spl-token --url "$KS_DEVNET_RPC_URL" --program-id "$KS_PUBLIC_SPL_TOKEN_2022_PROGRAM_ID" display "$KS_PUBLIC_DEVNET_TOKEN_2022_DESTINATION" && spl-token --url "$KS_DEVNET_RPC_URL" --program-id "$KS_PUBLIC_SPL_TOKEN_2022_PROGRAM_ID" display "$KS_PUBLIC_DEVNET_TOKEN_2022_CLOSE_ACCOUNT"
 ```

-Le compte `TOKEN_2022_CLOSE_ACCOUNT` doit rester vide jusqu'au scénario `CloseAccount`. Ne pas utiliser `account-info <adresse>` dans cette campagne : avec `spl-token-cli 5.5.0`, cette forme peut interpréter l'adresse comme un mint.
+Le compte `KS_PUBLIC_DEVNET_TOKEN_2022_CLOSE_ACCOUNT` doit rester vide jusqu'au scénario `CloseAccount`. Ne pas utiliser `account-info <adresse>` dans cette campagne : avec `spl-token-cli 5.5.0`, cette forme peut interpréter l'adresse comme un mint.

 ### C12 — Preuves applicatives communes

@@ -331,7 +331,7 @@ Un scénario n’est validé que si le replay ne produit ni échec fonctionnel n
 6. Dans le terminal B, exécuter le contrôle de tables de `C05`.
 7. Financer la pubkey par un faucet Web Devnet si le solde est insuffisant.
 8. Réexécuter `C04` dans le terminal B après financement.
-9. Avant chaque scénario, définir `KB_DEVNET_SCENARIO` dans le terminal B, puis exécuter `C06`.
+9. Avant chaque scénario, définir `KS_DEVNET_SCENARIO` dans le terminal B, puis exécuter `C06`.

 ## 6. Scénario S01 — Solana Core System Transfer

@@ -344,7 +344,7 @@ Valider la chaîne complète : préparation, simulation, envoi, confirmation, st
 1. Définir puis exécuter `C06` :

 ```bash
-export KB_DEVNET_SCENARIO="10-system-transfer"
+export KS_DEVNET_SCENARIO="10-system-transfer"
 ```

 2. Dans la fenêtre **Exécution Devnet — Solana Core** :
@@ -359,13 +359,13 @@ export KB_DEVNET_SCENARIO="10-system-transfer"
 4. Capturer séparément le solde du destinataire :

 ```bash
-export KB_DEVNET_RECIPIENT="COLLER_LE_DESTINATAIRE"
+export KS_DEVNET_RECIPIENT="COLLER_LE_DESTINATAIRE"

 solana balance \
-  "$KB_DEVNET_RECIPIENT" \
-  --url "$KB_DEVNET_RPC_URL" \
+  "$KS_DEVNET_RECIPIENT" \
+  --url "$KS_DEVNET_RPC_URL" \
  --commitment confirmed \
-  | tee "$KB_DEVNET_VALIDATION_DIR/${KB_DEVNET_SCENARIO}-recipient-after.txt"
+  | tee "$KS_DEVNET_VALIDATION_DIR/${KS_DEVNET_SCENARIO}-recipient-after.txt"
 ```

 5. Exécuter les contrôles applicatifs `C08` sur la signature.
@@ -398,7 +398,7 @@ Valider l’opération exécutable `spl.memo.add_memo`, l’événement observé
 1. Définir puis exécuter `C06` :

 ```bash
-export KB_DEVNET_SCENARIO="20-spl-memo-v4"
+export KS_DEVNET_SCENARIO="20-spl-memo-v4"
 ```

 2. Dans la fenêtre **Exécution Devnet — SPL** :
@@ -407,7 +407,7 @@ export KB_DEVNET_SCENARIO="20-spl-memo-v4"
   - vérifier le Program ID `Memo4c2pN8afCj432Lb7RMVKi9PbQnnW7ewFFaV3oAH` ;
   - vérifier le wallet signer ;
   - simuler puis confirmer l’envoi.
-3. Définir `KB_DEVNET_SIGNATURE` et exécuter `C07`.
+3. Définir `KS_DEVNET_SIGNATURE` et exécuter `C07`.
 4. Exécuter `C08` et vérifier précisément :
   - `processor_name = materializer.transaction.annotations` ;
   - `surface_code = spl.memo.v4` ;
@@ -441,22 +441,22 @@ Valider la dérivation et la création idempotente d’une ATA dont le mint appa
 2. Définir le scénario et capturer le solde :

 ```bash
-export KB_DEVNET_SCENARIO="30a-spl-ata-classic"
+export KS_DEVNET_SCENARIO="30a-spl-ata-classic"
 ```

 3. Exécuter `C06`.
 4. Copier la valeur affichée par :

 ```bash
-printf '%s\n' "$KB_DEVNET_CLASSIC_MINT"
+printf '%s\n' "$KS_DEVNET_CLASSIC_MINT"
 ```

 #### Procédure dans l’application

 1. Ouvrir la fenêtre **SPL Associated Token Account**.
 2. Utiliser :
-   - owner : wallet opérateur `KB_DEVNET_WALLET_PUBKEY` ;
-   - mint : `KB_DEVNET_CLASSIC_MINT` ;
+   - owner : wallet opérateur `KS_PUBLIC_DEVNET_WALLET_ADDRESS` ;
+   - mint : `KS_DEVNET_CLASSIC_MINT` ;
   - token program : SPL Token classique ;
   - payer : wallet opérateur.
 3. Dériver l’ATA et conserver son adresse.
@@ -464,7 +464,7 @@ printf '%s\n' "$KB_DEVNET_CLASSIC_MINT"
 5. Simuler `spl.associated_token_account.create_idempotent`.
 6. Contrôler le rent ceiling, le payer, l’owner, le mint, le token program et l’adresse ATA dérivée.
 7. Confirmer explicitement l’envoi.
-8. Définir `KB_DEVNET_SIGNATURE`, puis exécuter `C07`.
+8. Définir `KS_DEVNET_SIGNATURE`, puis exécuter `C07`.
 9. Exécuter `C12`.
 10. Réexécuter la création idempotente et vérifier qu’elle ne produit ni fausse création ni duplication des projections.

@@ -480,28 +480,28 @@ Valider la dérivation et la création idempotente d’une ATA dont le mint appa
 2. Définir le scénario et capturer le solde :

 ```bash
-export KB_DEVNET_SCENARIO="30b-spl-ata-token-2022"
+export KS_DEVNET_SCENARIO="30b-spl-ata-token-2022"
 ```

 3. Exécuter `C06`.
 4. Copier la valeur affichée par :

 ```bash
-printf '%s\n' "$KB_DEVNET_TOKEN_2022_MINT"
+printf '%s\n' "$KS_PUBLIC_DEVNET_TOKEN_2022_MINT"
 ```

 #### Procédure dans l’application

 1. Utiliser :
   - owner : le même wallet opérateur ;
-   - mint : `KB_DEVNET_TOKEN_2022_MINT` ;
+   - mint : `KS_PUBLIC_DEVNET_TOKEN_2022_MINT` ;
   - token program : Token-2022 ;
   - payer : wallet opérateur.
 2. Dériver l’ATA et conserver son adresse.
 3. Vérifier que le Program ID sélectionné est `TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb`.
 4. Vérifier que l’adresse dérivée diffère de l’ATA classique de S03A.
 5. Simuler puis envoyer `spl.associated_token_account.create_idempotent`.
-6. Définir `KB_DEVNET_SIGNATURE`, puis exécuter `C07`.
+6. Définir `KS_DEVNET_SIGNATURE`, puis exécuter `C07`.
 7. Exécuter `C12`.
 8. Rejouer la création idempotente.
 9. Vérifier séparément les faits parent ATA et les éventuels enfants CPI Token-2022, sans duplication.
@@ -533,13 +533,13 @@ Elle ne permet pas encore d’enchaîner depuis l’interface `InitializeMint`,
 1. Réutiliser le mint classique de `C08` :

 ```bash
-export KB_SPL_TOKEN_PROGRAM_ID="TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" && export KB_DEVNET_CLASSIC_MINT_KEYPAIR="$PWD/wallets/temporary/local_devnet/mints/ata-classic-mint.json" && export KB_DEVNET_CLASSIC_MINT="$(solana-keygen pubkey "$KB_DEVNET_CLASSIC_MINT_KEYPAIR")"
+export KS_PUBLIC_SPL_TOKEN_PROGRAM_ID="TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" && export KS_DEVNET_CLASSIC_MINT_KEYPAIR="$PWD/wallets/temporary/local_devnet/mints/ata-classic-mint.json" && export KS_DEVNET_CLASSIC_MINT="$(solana-keygen pubkey "$KS_DEVNET_CLASSIC_MINT_KEYPAIR")"
 ```

 2. Définir le scénario :

 ```bash
-export KB_DEVNET_SCENARIO="40-spl-token"
+export KS_DEVNET_SCENARIO="40-spl-token"
 ```

 3. Exécuter `C06`.
@@ -547,7 +547,7 @@ export KB_DEVNET_SCENARIO="40-spl-token"
 5. Vérifier les comptes token avant l’opération :

 ```bash
-spl-token --url "$KB_DEVNET_RPC_URL" --program-id "$KB_SPL_TOKEN_PROGRAM_ID" display "$KB_DEVNET_CLASSIC_SOURCE_ATA" && spl-token --url "$KB_DEVNET_RPC_URL" --program-id "$KB_SPL_TOKEN_PROGRAM_ID" display "$KB_DEVNET_CLASSIC_DESTINATION_ATA"
+spl-token --url "$KS_DEVNET_RPC_URL" --program-id "$KS_PUBLIC_SPL_TOKEN_PROGRAM_ID" display "$KS_DEVNET_CLASSIC_SOURCE_ATA" && spl-token --url "$KS_DEVNET_RPC_URL" --program-id "$KS_PUBLIC_SPL_TOKEN_PROGRAM_ID" display "$KS_DEVNET_CLASSIC_DESTINATION_ATA"
 ```

 ### Valeurs à saisir dans l’application
@@ -556,17 +556,17 @@ Dans **Décodeur spl_token — TransferChecked** :

 | Champ              | Valeur                                     |
 |--------------------|--------------------------------------------|
-| Compte source      | `$KB_DEVNET_CLASSIC_SOURCE_ATA`            |
-| Mint               | `$KB_DEVNET_CLASSIC_MINT`                  |
-| Compte destination | `$KB_DEVNET_CLASSIC_DESTINATION_ATA`       |
-| Autorité simple    | `$KB_DEVNET_WALLET_PUBKEY`                 |
+| Compte source      | `$KS_DEVNET_CLASSIC_SOURCE_ATA`            |
+| Mint               | `$KS_DEVNET_CLASSIC_MINT`                  |
+| Compte destination | `$KS_DEVNET_CLASSIC_DESTINATION_ATA`       |
+| Autorité simple    | `$KS_PUBLIC_DEVNET_WALLET_ADDRESS`                 |
 | Montant brut exact | `1000000000` pour 1 token avec 9 décimales |
 | Decimals           | `9`                                        |

 Afficher les valeurs à copier :

 ```bash
-printf 'source=%s\nmint=%s\ndestination=%s\nauthority=%s\namount_raw=1000000000\ndecimals=9\n' "$KB_DEVNET_CLASSIC_SOURCE_ATA" "$KB_DEVNET_CLASSIC_MINT" "$KB_DEVNET_CLASSIC_DESTINATION_ATA" "$KB_DEVNET_WALLET_PUBKEY"
+printf 'source=%s\nmint=%s\ndestination=%s\nauthority=%s\namount_raw=1000000000\ndecimals=9\n' "$KS_DEVNET_CLASSIC_SOURCE_ATA" "$KS_DEVNET_CLASSIC_MINT" "$KS_DEVNET_CLASSIC_DESTINATION_ATA" "$KS_PUBLIC_DEVNET_WALLET_ADDRESS"
 ```

 ### Exécution
@@ -584,14 +584,14 @@ printf 'source=%s\nmint=%s\ndestination=%s\nauthority=%s\namount_raw=1000000000\
 5. Copier la signature dans :

 ```bash
-export KB_DEVNET_SIGNATURE="SIGNATURE_SPL_TOKEN"
+export KS_DEVNET_SIGNATURE="SIGNATURE_SPL_TOKEN"
 ```

 6. Exécuter `C07`, puis `C12`.
 7. Vérifier les comptes après transfert :

 ```bash
-spl-token --url "$KB_DEVNET_RPC_URL" --program-id "$KB_SPL_TOKEN_PROGRAM_ID" display "$KB_DEVNET_CLASSIC_SOURCE_ATA" && spl-token --url "$KB_DEVNET_RPC_URL" --program-id "$KB_SPL_TOKEN_PROGRAM_ID" display "$KB_DEVNET_CLASSIC_DESTINATION_ATA"
+spl-token --url "$KS_DEVNET_RPC_URL" --program-id "$KS_PUBLIC_SPL_TOKEN_PROGRAM_ID" display "$KS_DEVNET_CLASSIC_SOURCE_ATA" && spl-token --url "$KS_DEVNET_RPC_URL" --program-id "$KS_PUBLIC_SPL_TOKEN_PROGRAM_ID" display "$KS_DEVNET_CLASSIC_DESTINATION_ATA"
 ```

 ### Critères de validation
@@ -614,7 +614,7 @@ Le journal métier SPL Token peut rester à `empty` après une simulation seule.
 1. Définir le scénario et exécuter `C06` :

 ```bash
-export KB_DEVNET_SCENARIO="50-spl-token-2022"
+export KS_DEVNET_SCENARIO="50-spl-token-2022"
 ```

 2. Exécuter `C11` pour créer ou réutiliser la fixture.
@@ -647,7 +647,7 @@ Champs utilisés :
 - source/cible : compte token à créditer ;
 - mint : mint Token-2022 ;
 - autorité : mint authority ;
- montant brut : `TOKEN_2022_MINT_AMOUNT_RAW` chargé depuis la fixture ;
+- montant brut : `KS_PUBLIC_DEVNET_TOKEN_2022_MINT_AMOUNT_RAW` chargé depuis la fixture ;
 - décimales : valeur de la fixture.

 Avec la fixture par défaut, le mint initial est `10000000000` unités brutes, soit 10 tokens avec 9 décimales. Cette quantité couvre ensuite le transfert, l'approbation et le burn prévus.
@@ -732,13 +732,13 @@ Le compte doit être vide et satisfaire toutes les préconditions de fermeture.
 4. contrôler le plan, les owners, les autorités, le montant et les extensions ;
 5. cocher la confirmation opérateur ;
 6. envoyer ;
-7. définir immédiatement `KB_DEVNET_SIGNATURE` avec la signature affichée pour cette sous-opération ;
+7. définir immédiatement `KS_DEVNET_SIGNATURE` avec la signature affichée pour cette sous-opération ;
 8. vérifier qu'elle diffère de la signature du scénario précédent, puis exécuter `C07` ;
 9. appliquer `C12` ;
 10. conserver un fichier de preuve distinct en modifiant temporairement le préfixe, par exemple :

 ```bash
-export KB_DEVNET_SCENARIO="50a-token-2022-mint-to-checked"
+export KS_DEVNET_SCENARIO="50a-token-2022-mint-to-checked"
 ```

 puis `50b`, `50c`, etc., avant chaque appel à `C07`.