From f11f0921b091a05293cb86151600a08e8ff345f2 Mon Sep 17 00:00:00 2001 From: SinuS Von SifriduS Date: Fri, 21 Aug 2026 10:50:36 +0200 Subject: [PATCH] v0.2.6-pre.007 --- Cargo.toml | 4 +- ROADMAP.md | 4 +- crates/ksp-app-wallet-desk/Cargo.toml | 3 +- crates/ksp-app-wallet-desk/frontend/main.html | 46 +++- .../ksp-app-wallet-desk/frontend/ts/main.ts | 87 ++++++- crates/ksp-app-wallet-desk/package.json | 2 +- crates/ksp-app-wallet-desk/src/app_state.rs | 130 +++++++++- crates/ksp-app-wallet-desk/src/constants.rs | 4 +- crates/ksp-app-wallet-desk/src/dto_common.rs | 14 +- crates/ksp-app-wallet-desk/src/errors.rs | 5 +- crates/ksp-app-wallet-desk/src/lib.rs | 16 +- crates/ksp-app-wallet-desk/src/tauri.rs | 12 +- .../src/transport_runtime.rs | 97 +++++++ .../ksp-app-wallet-desk/src/wallet_balance.rs | 39 +++ crates/ksp-app-wallet-desk/tauri.conf.json | 2 +- .../tests/config_composition.rs | 50 +++- .../tests/desktop_contract.rs | 28 +- .../tests/desktop_security.rs | 26 +- .../unit_tests/wallet_balance.rs | 13 + crates/ksp-config-lib/src/transport.rs | 20 +- crates/ksp-config-lib/tests/public_api.rs | 3 +- crates/ksp-config-lib/unit_tests/transport.rs | 36 ++- deltas/0.2.6/pre.007.md | 243 ++++++++++++++++++ docs/plans/002-FUNCTIONAL_RELEASE_SEQUENCE.md | 4 +- docs/plans/013-V0_2_6_WALLET_DESK_PLAN.md | 25 +- 25 files changed, 871 insertions(+), 42 deletions(-) create mode 100644 crates/ksp-app-wallet-desk/src/transport_runtime.rs create mode 100644 crates/ksp-app-wallet-desk/src/wallet_balance.rs create mode 100644 crates/ksp-app-wallet-desk/unit_tests/wallet_balance.rs create mode 100644 deltas/0.2.6/pre.007.md diff --git a/Cargo.toml b/Cargo.toml index 74d9b01..f7d7213 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,12 +1,12 @@ # file: Cargo.toml -# version: 173 +# version: 174 [workspace] resolver = "3" members = ["crates/ksp-app-config-desk", "crates/ksp-app-wallet-desk", "crates/ksp-config-lib", "crates/ksp-core-lib", "crates/ksp-logging-lib", "crates/ksp-onchain-transport-lib", "crates/ksp-wallet-lib"] [workspace.package] -version = "0.2.6-pre.6.fix.1" +version = "0.2.6-pre.7" edition = "2024" license = "MIT" repository = "https://git.sasedev.com/Sasedev/khadhroony-solana-project" diff --git a/ROADMAP.md b/ROADMAP.md index 8b27e03..8ecdf1c 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -1,5 +1,5 @@ - + # Roadmap KSP @@ -50,7 +50,7 @@ Le roadmap décrit les objectifs à atteindre et les grandes étapes prévues. U - [X] `0.2.3` — HTTP Transactions stable : 11/11 wrappers typés publiés, classification `8 Read / 2 WriteSubmission / 1 Simulation`, no-resend ambigu prouvé pour les write submissions, `KSP-TRANSPORT-007` réaudité conforme sur les 37 wrappers HTTP courants, graphes Cargo et deux smokes Devnet validés ; `0.2.4` reprend les 15 Blocks/Economics restants. - [X] `0.2.4` — HTTP Blocks + Economics stable : 15/15 wrappers `V0_2_4` publiés, surface typed complète à 52/52 méthodes courantes, 14/14 historiques conservées, réaudit SIMD/inventaire final et `KSP-TRANSPORT-007` global validés ; deux smokes Devnet passés avant publication. - [X] `0.2.5` — Wallet foundation stable : `.kspwallet` V1, VIEW/OWNER indépendants, Argon2id/XChaCha20-Poly1305, autorité Ed25519 OWNER, persistence no-clobber, signature, administration/rotations/révocation VIEW forte, import/export Solana CLI JSON + Base58, canaris adversariaux, interop externe et documentation durable publiés. La clôture `pre.010-fix.001`–`fix.003` ajoute `ed25519-dalek 3.0.0` direct, normalise le Rust workspace et installe l’audit structurel Python complémentaire à rustfmt/Clippy. `Pubkey` reste via `ksp-core-lib`, la keypair reste encapsulée dans Wallet et Config/Transport/ExecutionPolicy/Store/Tauri restent hors Wallet. -- [ ] `0.2.6` — Introduire `ksp-app-wallet-desk` utilisant Config composite + Wallet + transport HTTP. `pre.001` fixe le sizing et le gabarit ; `pre.002` matérialise la crate Tauri et son shell splash/main avec Config + Logging bootstrap, ports `1432/1433`, Bootstrap, Font Awesome, DataTables/Select, SimpleBar, resize-observer-polyfill, TS-RS et bridge frontend Logging. `pre.003` matérialise `cfg.std.wallet`/`schema.std.wallet`, le composite `cfg.composite.ksp-app-wallet-desk`, `ResolvedWalletConfig`, `wallets_directory` global + `wallets_subdirectory` par profil et la préparation automatique des répertoires côté application avec logs debug/error. `pre.003-fix.001` corrige les premiers canaris Config et active la trace des interactions frontend sans valeur de contrôle. `pre.003-fix.002` corrige le scanner `.env.example` sur les fragments d’identifiants Rust, généralise `std.logging` avec les profils console-only, `file_info`, `superdev` et `supertrace`, et sélectionne temporairement `supertrace` dans le composite Wallet Desk. `pre.003-fix.003` corrige les canaris de ce changement : closures explicites compatibles avec `clippy::implicit_return` et distinction entre fragment KSP incorporé dans un identifiant et nom d’environnement concret suffixé. `pre.003-fix.004` corrige les cinq closures restantes du canari de composition Wallet Desk afin que `cargo clippy --workspace --all-targets` respecte intégralement `clippy::implicit_return`, sans modifier Config ni Logging. `pre.004` branche ensuite l’inventory réel `.kspwallet` sur le répertoire effectif Config : enumeration non récursive, extension exacte, fichiers réguliers uniquement, rejet des symlinks, inspection locked via `ksp-wallet-lib`, diagnostics sûrs par ligne, DataTable réel, refresh et sélection root-scoped revalidée côté Rust sans Pubkey/alias/notes. `pre.004-fix.001` limite les deux réexports crate-root internes utilisés uniquement par les unit tests à `#[cfg(test)]`, afin de fermer les warnings `unused_imports` observés par `cargo check`, Clippy, tests et `tauri dev` sans modifier le comportement d’inventory. `pre.005` ajoute la création native `create_wallet_file_v1`, le formulaire OWNER + VIEW optionnel et le premier `WalletSession` durable côté Rust : OWNER reste ouvert après création, sélection existante reste Locked, tandis que lock/deselect/refresh/changement de wallet détruisent le handle et purgent les projections protégées. `pre.005-fix.001` corrige le premier gate opérateur de cette tranche : `WalletOwner` est indirecté par `Box` dans `WalletSession::Owner` pour fermer `clippy::large_enum_variant`, et le canari `desktop_security` retrouve explicitement le début de `WalletCreateRequestDto` avant de vérifier que les passwords restent request-only. `pre.006` ajoute ensuite les unlock explicites VIEW/OWNER : saisie manuelle request-only, découverte des candidats `KSP_SECRET_WALLET_PASS_*` exclusivement via Config, ordre filename normalisé puis numérique puis nommé, tentative configurée uniquement sur action utilisateur, état transitoire `PrivilegedOperation` pendant Argon2 et projection frontend limitée au nombre de candidats sans nom/suffixe/valeur. `pre.006-fix.001` corrige uniquement les deux canaris statiques de sécurité : ils inspectent désormais les champs réels de `WalletAuthorizedDto` au lieu de considérer le mot `password` présent dans sa documentation de `configured_secret_candidate_count` comme une fuite de champ. Les tranches suivantes ajoutent unlock manuel/configuré, secrets `KSP_SECRET_WALLET_PASS_*`, identité autorisée + `getBalance`, puis administration/import/export, avec une dernière tranche prévue pour README/USAGE/docs/validation, prompt `0.2.7` et build Tauri final. +- [ ] `0.2.6` — Introduire `ksp-app-wallet-desk` utilisant Config composite + Wallet + transport HTTP. `pre.001` fixe le sizing et le gabarit ; `pre.002` matérialise la crate Tauri et son shell splash/main avec Config + Logging bootstrap, ports `1432/1433`, Bootstrap, Font Awesome, DataTables/Select, SimpleBar, resize-observer-polyfill, TS-RS et bridge frontend Logging. `pre.003` matérialise `cfg.std.wallet`/`schema.std.wallet`, le composite `cfg.composite.ksp-app-wallet-desk`, `ResolvedWalletConfig`, `wallets_directory` global + `wallets_subdirectory` par profil et la préparation automatique des répertoires côté application avec logs debug/error. `pre.003-fix.001` corrige les premiers canaris Config et active la trace des interactions frontend sans valeur de contrôle. `pre.003-fix.002` corrige le scanner `.env.example` sur les fragments d’identifiants Rust, généralise `std.logging` avec les profils console-only, `file_info`, `superdev` et `supertrace`, et sélectionne temporairement `supertrace` dans le composite Wallet Desk. `pre.003-fix.003` corrige les canaris de ce changement : closures explicites compatibles avec `clippy::implicit_return` et distinction entre fragment KSP incorporé dans un identifiant et nom d’environnement concret suffixé. `pre.003-fix.004` corrige les cinq closures restantes du canari de composition Wallet Desk afin que `cargo clippy --workspace --all-targets` respecte intégralement `clippy::implicit_return`, sans modifier Config ni Logging. `pre.004` branche ensuite l’inventory réel `.kspwallet` sur le répertoire effectif Config : enumeration non récursive, extension exacte, fichiers réguliers uniquement, rejet des symlinks, inspection locked via `ksp-wallet-lib`, diagnostics sûrs par ligne, DataTable réel, refresh et sélection root-scoped revalidée côté Rust sans Pubkey/alias/notes. `pre.004-fix.001` limite les deux réexports crate-root internes utilisés uniquement par les unit tests à `#[cfg(test)]`, afin de fermer les warnings `unused_imports` observés par `cargo check`, Clippy, tests et `tauri dev` sans modifier le comportement d’inventory. `pre.005` ajoute la création native `create_wallet_file_v1`, le formulaire OWNER + VIEW optionnel et le premier `WalletSession` durable côté Rust : OWNER reste ouvert après création, sélection existante reste Locked, tandis que lock/deselect/refresh/changement de wallet détruisent le handle et purgent les projections protégées. `pre.005-fix.001` corrige le premier gate opérateur de cette tranche : `WalletOwner` est indirecté par `Box` dans `WalletSession::Owner` pour fermer `clippy::large_enum_variant`, et le canari `desktop_security` retrouve explicitement le début de `WalletCreateRequestDto` avant de vérifier que les passwords restent request-only. `pre.006` ajoute ensuite les unlock explicites VIEW/OWNER : saisie manuelle request-only, découverte des candidats `KSP_SECRET_WALLET_PASS_*` exclusivement via Config, ordre filename normalisé puis numérique puis nommé, tentative configurée uniquement sur action utilisateur, état transitoire `PrivilegedOperation` pendant Argon2 et projection frontend limitée au nombre de candidats sans nom/suffixe/valeur. `pre.006-fix.001` corrige uniquement les deux canaris statiques de sécurité : ils inspectent désormais les champs réels de `WalletAuthorizedDto` au lieu de considérer le mot `password` présent dans sa documentation de `configured_secret_candidate_count` comme une fuite de champ. `pre.007` ferme ensuite le MVP obligatoire : l'adapter Transport accepte un profil déjà sélectionné par composite avec provenance `Composite`, Wallet Desk construit `HttpTransportPool` au bootstrap, expose des diagnostics profile/cluster/provider sans URL, extrait la Pubkey uniquement d'une session VIEW/OWNER Rust, puis appelle le wrapper typé `getBalance` en `confirmed` et projette lamports exacts, SOL décimal, slot et `api_version`. Le frontend ne fournit ni Pubkey ni endpoint au refresh et toute balance est purgée lors du lock/deselect/changement de wallet. Les tranches suivantes ajoutent administration/import/export, avec une dernière tranche prévue pour README/USAGE/docs/validation, prompt `0.2.7` et build Tauri final. - [ ] `0.2.7` — Étendre `ksp-onchain-transport-lib` au WebSocket Solana standard complet ; permettre plusieurs sessions sur une même URL sans imposer encore un pool automatique complexe. - [ ] `0.2.8` — Ajouter Helius LaserStream WebSocket comme extension du moteur WebSocket standard, sans duplication de client. - [ ] `0.2.9` — Ajouter une première fondation Yellowstone gRPC standard/provider-neutral ; dimensionner la surface exacte à `pre.001` selon la documentation normative actuelle. diff --git a/crates/ksp-app-wallet-desk/Cargo.toml b/crates/ksp-app-wallet-desk/Cargo.toml index b5d7c78..7a14177 100644 --- a/crates/ksp-app-wallet-desk/Cargo.toml +++ b/crates/ksp-app-wallet-desk/Cargo.toml @@ -1,5 +1,5 @@ # file: crates/ksp-app-wallet-desk/Cargo.toml -# version: 2 +# version: 3 [package] name = "ksp-app-wallet-desk" @@ -27,6 +27,7 @@ fs2.workspace = true ksp-config-lib = { path = "../ksp-config-lib" } ksp-core-lib = { path = "../ksp-core-lib" } ksp-logging-lib = { path = "../ksp-logging-lib" } +ksp-onchain-transport-lib = { path = "../ksp-onchain-transport-lib" } ksp-wallet-lib = { path = "../ksp-wallet-lib" } serde = { workspace = true, features = ["derive"] } tauri.workspace = true diff --git a/crates/ksp-app-wallet-desk/frontend/main.html b/crates/ksp-app-wallet-desk/frontend/main.html index f2786e4..fef5fc0 100644 --- a/crates/ksp-app-wallet-desk/frontend/main.html +++ b/crates/ksp-app-wallet-desk/frontend/main.html @@ -40,9 +40,9 @@

Dashboard

-

Création native, sessions durables et unlock explicite VIEW/OWNER actifs.

+

Identité autorisée et balance SOL via le Transport HTTP composite sont actives.

- 0.2.6-pre.006 + 0.2.6-pre.007
@@ -56,6 +56,11 @@
Documents Config enregistrés
—
Profil composite
—
Profil Logging
—
+
Profil Transport
—
+
Cluster Transport
—
+
Provider Transport
—
+
Endpoints Transport
—
+
Rôle Transport
—
Profil Wallet
—
Fallback Logging
—
Racine Wallet
—
@@ -80,6 +85,7 @@
Pubkey
—
Alias
—
Notes
—
+
Balance SOL
—
@@ -159,7 +165,29 @@
- + - + diff --git a/crates/ksp-app-wallet-desk/frontend/ts/main.ts b/crates/ksp-app-wallet-desk/frontend/ts/main.ts index 258d9c1..ebac916 100644 --- a/crates/ksp-app-wallet-desk/frontend/ts/main.ts +++ b/crates/ksp-app-wallet-desk/frontend/ts/main.ts @@ -1,5 +1,5 @@ // file: crates/ksp-app-wallet-desk/frontend/ts/main.ts -// version: 6 +// version: 7 import "bootstrap"; import DataTable from "datatables.net-bs5"; @@ -7,6 +7,7 @@ import "datatables.net-select-bs5"; import ResizeObserver from "resize-observer-polyfill"; import "simplebar"; import { getCurrentWindow } from "@tauri-apps/api/window"; +import type { WalletBalanceDto } from "./bindings/ksp_app_wallet_desk/wallet_balance/WalletBalanceDto.ts"; import type { RuntimeStatusDto } from "./bindings/ksp_app_wallet_desk/dto_common/RuntimeStatusDto.ts"; import type { LockedWalletDto } from "./bindings/ksp_app_wallet_desk/wallet_inventory/LockedWalletDto.ts"; import type { WalletInventoryEntryDto } from "./bindings/ksp_app_wallet_desk/wallet_inventory/WalletInventoryEntryDto.ts"; @@ -169,7 +170,7 @@ function initializeWalletTable(): void { zeroRecords: "Aucun wallet correspondant.", }, }); - frontendDebug("main", "Wallet inventory DataTable initialized", { phase: "pre.006-wallet-unlock" }); + frontendDebug("main", "Wallet inventory DataTable initialized", { phase: "pre.007-wallet-balance" }); } function renderWalletInventory(entries: WalletInventoryEntryDto[]): void { @@ -193,6 +194,7 @@ function setText(selector: string, value: string): void { } function updateSessionActions(): void { + const refreshBalance = document.querySelector("#refreshWalletBalance"); const lock = document.querySelector('[data-shell-action="lock"]'); const deselect = document.querySelector('[data-shell-action="deselect"]'); if (lock) { @@ -201,6 +203,9 @@ function updateSessionActions(): void { if (deselect) { deselect.disabled = activeSessionState === "no_selection" || activeSessionState === "privileged_operation"; } + if (refreshBalance) { + refreshBalance.disabled = activeSessionState !== "view_open" && activeSessionState !== "owner_open"; + } updateUnlockActions(); } @@ -255,10 +260,24 @@ function clearUnlockSensitiveInputs(): void { } } +function clearBalanceProjection(): void { + setText("#currentWalletBalanceSol", "—"); + setText("#detailsBalanceLamports", "—"); + setText("#detailsBalanceSol", "—"); + setText("#detailsBalanceSlot", "—"); + setText("#detailsBalanceApiVersion", "—"); + setText("#detailsBalanceTransport", "—"); + setText("#balanceStatus", "Unlock VIEW ou OWNER pour interroger getBalance."); +} + function clearAuthorizedProjection(): void { setText("#currentWalletPubkey", "—"); setText("#currentWalletAlias", "—"); setText("#currentWalletNotes", "—"); + setText("#detailsWalletPubkey", "—"); + setText("#detailsWalletAlias", "—"); + setText("#detailsWalletNotes", "—"); + clearBalanceProjection(); clearCreateFormSensitiveInputs(); clearUnlockSensitiveInputs(); } @@ -325,7 +344,13 @@ function renderAuthorizedWallet(wallet: WalletAuthorizedDto): void { setText("#currentWalletSecretCandidates", configuredSecretCandidateCount.toString()); setText("#currentWalletPubkey", wallet.pubkey); setText("#currentWalletAlias", wallet.alias ?? "—"); - setText("#currentWalletNotes", wallet.notes.length === 0 ? "—" : wallet.notes.map(note => note.text).join(" · ")); + const notesText = wallet.notes.length === 0 ? "—" : wallet.notes.map(note => note.text).join(" · "); + setText("#currentWalletNotes", notesText); + setText("#detailsWalletPubkey", wallet.pubkey); + setText("#detailsWalletAlias", wallet.alias ?? "—"); + setText("#detailsWalletNotes", notesText); + clearBalanceProjection(); + setText("#balanceStatus", "Session autorisée. Refresh balance appelle getBalance avec la Pubkey détenue par Rust."); setText("#unlockStatus", `${capabilityLabel} ouvert. Lock pour purger le handle autorisé.`); updateSessionActions(); frontendDebug("main", "Authorized Wallet session rendered", { @@ -570,10 +595,61 @@ async function deselectCurrentWallet(): Promise { } } +function renderWalletBalance(balance: WalletBalanceDto): void { + if (activeWalletId !== balance.walletId || (activeSessionState !== "view_open" && activeSessionState !== "owner_open")) { + frontendWarn("main", "Stale Wallet balance response ignored", { walletId: balance.walletId }); + return; + } + setText("#currentWalletBalanceSol", balance.sol); + setText("#detailsBalanceLamports", balance.lamports); + setText("#detailsBalanceSol", balance.sol); + setText("#detailsBalanceSlot", balance.slot.toString()); + setText("#detailsBalanceApiVersion", balance.apiVersion ?? "—"); + setText("#detailsBalanceTransport", `${balance.transportProfile} / ${balance.transportRole}`); + setText("#balanceStatus", "Balance réseau actualisée."); + frontendInfo("main", "Wallet balance rendered", { lamports: balance.lamports, slot: balance.slot, walletId: balance.walletId }); +} + +async function refreshWalletBalance(): Promise { + if (!activeWalletId || (activeSessionState !== "view_open" && activeSessionState !== "owner_open")) { + return; + } + const walletId = activeWalletId; + setText("#balanceStatus", "Interrogation getBalance en cours…"); + frontendDebug("main", "Wallet balance refresh requested", { walletId }); + try { + const balance = await invokeKsp("main", "refresh_wallet_balance"); + renderWalletBalance(balance); + } catch { + if (activeWalletId === walletId) { + clearBalanceProjection(); + setText("#balanceStatus", "Échec getBalance. Consulter le diagnostic et les logs."); + } + frontendWarn("main", "Wallet balance refresh failed", { walletId }); + } +} + +function bindBalanceActions(): void { + document.querySelector("#refreshWalletBalance")?.addEventListener("click", () => { + void refreshWalletBalance(); + }); + frontendTrace("main", "Wallet balance action handlers installed"); +} + function renderRuntimeStatus(status: RuntimeStatusDto): void { setText("#runtimeVersion", status.applicationVersion); setText("#runtimeCompositeProfile", status.activeCompositeProfile); setText("#runtimeLoggingProfile", status.activeLoggingProfile ?? "fallback transitoire"); + setText("#runtimeTransportProfile", status.activeTransportProfile); + setText("#runtimeTransportClusters", status.transportClusters.join(", ") || "—"); + setText("#runtimeTransportProviders", status.transportProviders.join(", ") || "—"); + setText("#runtimeTransportEndpoints", `${status.transportAvailableEndpointCount}/${status.transportEndpointCount} disponibles`); + setText("#runtimeTransportRole", status.transportRole); + setText("#diagnosticsTransportProfile", status.activeTransportProfile); + setText("#diagnosticsTransportClusters", status.transportClusters.join(", ") || "—"); + setText("#diagnosticsTransportProviders", status.transportProviders.join(", ") || "—"); + setText("#diagnosticsTransportEndpoints", `${status.transportAvailableEndpointCount}/${status.transportEndpointCount}`); + setText("#diagnosticsTransportRole", status.transportRole); setText("#runtimeWalletProfile", status.activeWalletProfile); setText("#runtimeLoggingFallback", status.fallbackLoggingActive ? "oui" : "non"); setText("#runtimeConfigDocuments", status.configDocumentCount.toString()); @@ -582,11 +658,13 @@ function renderRuntimeStatus(status: RuntimeStatusDto): void { setText("#runtimeEffectiveWalletsDirectory", status.effectiveWalletsDirectory); setText("#runtimeWalletDirectoryCreated", status.effectiveWalletsDirectoryCreatedOnStartup ? "oui" : "non, déjà présent"); setText("#runtimeShellPhase", status.shellPhase); - setText("#shellStatus", "Config résolue ; création et unlock VIEW/OWNER prêts."); + setText("#shellStatus", "Config/Transport résolus ; VIEW/OWNER et getBalance prêts."); frontendTrace("main", "Wallet Desk runtime status rendered", { compositeProfile: status.activeCompositeProfile, fallbackLoggingActive: status.fallbackLoggingActive, shellPhase: status.shellPhase, + transportEndpointCount: status.transportEndpointCount, + transportProfile: status.activeTransportProfile, walletDirectoryCreatedOnStartup: status.effectiveWalletsDirectoryCreatedOnStartup, walletProfile: status.activeWalletProfile, }); @@ -629,6 +707,7 @@ async function initializeMain(): Promise { bindWalletTableSelection(); bindCreateWalletForm(); bindUnlockActions(); + bindBalanceActions(); bindShellActions(); clearSelectedWallet(); activateView("dashboard", "startup"); diff --git a/crates/ksp-app-wallet-desk/package.json b/crates/ksp-app-wallet-desk/package.json index a545735..b415629 100644 --- a/crates/ksp-app-wallet-desk/package.json +++ b/crates/ksp-app-wallet-desk/package.json @@ -1,7 +1,7 @@ { "name": "ksp-app-wallet-desk", "private": true, - "version": "0.2.6-pre.6.fix.1", + "version": "0.2.6-pre.7", "type": "module", "scripts": { "dev": "vite", diff --git a/crates/ksp-app-wallet-desk/src/app_state.rs b/crates/ksp-app-wallet-desk/src/app_state.rs index 1f6fedd..96cbdeb 100644 --- a/crates/ksp-app-wallet-desk/src/app_state.rs +++ b/crates/ksp-app-wallet-desk/src/app_state.rs @@ -1,5 +1,5 @@ // file: crates/ksp-app-wallet-desk/src/app_state.rs -// version: 7 +// version: 8 //! Shared backend state owned by the Wallet Desk Tauri application. @@ -9,6 +9,7 @@ pub(crate) struct AppState { logging_runtime: std::sync::Mutex, splash_settings: crate::SplashSettings, splash_sequence_started: std::sync::atomic::AtomicBool, + transport_runtime: crate::TransportRuntime, wallet_config_startup: crate::WalletConfigStartup, wallet_session: std::sync::Mutex, } @@ -31,6 +32,14 @@ impl AppState { std::result::Result::Ok(value) => value, std::result::Result::Err(error) => return std::result::Result::Err(error), }; + let transport_runtime = crate::initialize_transport(&config_management); + let transport_runtime = match transport_runtime { + std::result::Result::Ok(value) => value, + std::result::Result::Err(error) => { + ksp_logging_lib::error!(target: crate::TRACING_TARGET, domain = crate::TRACING_DOMAIN_BOOTSTRAP, error_domain = error.code().domain(), error_code = error.code().code(), "Wallet Desk Config/Transport bootstrap failed"); + return std::result::Result::Err(error); + }, + }; let wallet_config_startup = crate::initialize_wallet_config(&config_management); let wallet_config_startup = match wallet_config_startup { std::result::Result::Ok(value) => value, @@ -58,6 +67,7 @@ impl AppState { }), splash_settings, splash_sequence_started: std::sync::atomic::AtomicBool::new(false), + transport_runtime, wallet_config_startup, wallet_session: std::sync::Mutex::new(crate::WalletSession::no_selection()), }); @@ -90,20 +100,37 @@ impl AppState { }, }; let _keep_guard_alive = &runtime.guard; + let transport_snapshot = self.transport_runtime.pool().snapshot(); + let transport_available_endpoint_count = count_to_u32(transport_snapshot.available_endpoint_count(), "available Transport endpoints"); + let transport_available_endpoint_count = match transport_available_endpoint_count { + std::result::Result::Ok(value) => value, + std::result::Result::Err(error) => return std::result::Result::Err(error), + }; + let transport_endpoint_count = count_to_u32(transport_snapshot.endpoint_count(), "Transport endpoints"); + let transport_endpoint_count = match transport_endpoint_count { + std::result::Result::Ok(value) => value, + std::result::Result::Err(error) => return std::result::Result::Err(error), + }; let resolved = self.wallet_config_startup.resolved(); let wallets_subdirectory = resolved.wallets_subdirectory().map(|value| return value.to_string_lossy().into_owned()); return std::result::Result::Ok(crate::RuntimeStatusDto { application_version: env!("CARGO_PKG_VERSION").to_owned(), active_composite_profile: self.wallet_config_startup.composite_profile_id().to_owned(), active_logging_profile: runtime.active_profile_id.clone(), + active_transport_profile: self.transport_runtime.profile_id().to_owned(), active_wallet_profile: resolved.profile_id().to_owned(), config_document_count: document_count, effective_wallets_directory: resolved.effective_wallets_directory().to_string_lossy().into_owned(), effective_wallets_directory_created_on_startup: self.wallet_config_startup.effective_directory_created_on_startup(), fallback_logging_active: runtime.fallback_active, root_wallets_directory_created_on_startup: self.wallet_config_startup.root_directory_created_on_startup(), - shell_phase: "pre.006-wallet-unlock".to_owned(), + shell_phase: "pre.007-wallet-balance".to_owned(), startup_diagnostic: runtime.startup_diagnostic.clone(), + transport_available_endpoint_count, + transport_clusters: self.transport_runtime.clusters(), + transport_endpoint_count, + transport_providers: self.transport_runtime.providers(), + transport_role: self.transport_runtime.role().as_str().to_owned(), wallets_directory: resolved.wallets_directory().to_string_lossy().into_owned(), wallets_subdirectory, }); @@ -524,6 +551,87 @@ impl AppState { }; } + /// Refreshes the native SOL balance for the currently authorized VIEW/OWNER Wallet. + pub(crate) async fn refresh_wallet_balance(&self) -> ksp_core_lib::Result { + let context = self.authorized_balance_context(); + let context = match context { + std::result::Result::Ok(value) => value, + std::result::Result::Err(error) => return std::result::Result::Err(error), + }; + let config = ksp_onchain_transport_lib::GetBalanceConfig::new( + std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed), + std::option::Option::None, + ); + ksp_logging_lib::debug!(target: crate::TRACING_TARGET, domain = crate::TRACING_DOMAIN_TRANSPORT, wallet_id = context.wallet_id.as_str(), capability = context.capability, transport_profile = self.transport_runtime.profile_id(), transport_role = self.transport_runtime.role().as_str(), "Wallet balance refresh started"); + let result = self.transport_runtime.pool().get_balance(self.transport_runtime.role(), &context.pubkey, std::option::Option::Some(&config)).await; + let result = match result { + std::result::Result::Ok(value) => value, + std::result::Result::Err(error) => { + ksp_logging_lib::warn!(target: crate::TRACING_TARGET, domain = crate::TRACING_DOMAIN_TRANSPORT, wallet_id = context.wallet_id.as_str(), capability = context.capability, error_domain = error.code().domain(), error_code = error.code().code(), "Wallet balance refresh failed"); + return std::result::Result::Err(error); + }, + }; + if !self.balance_context_is_current(&context) { + return std::result::Result::Err(ksp_core_lib::Error::new( + crate::ERROR_CODE_WALLET_SESSION_INVALID, + "Wallet balance refresh completed after the authorized session changed", + )); + } + let lamports = result.value(); + let dto = crate::WalletBalanceDto { + api_version: result.context().api_version().map(str::to_owned), + lamports: lamports.to_string(), + slot: result.context().slot(), + sol: crate::format_lamports_as_sol(lamports), + transport_profile: self.transport_runtime.profile_id().to_owned(), + transport_role: self.transport_runtime.role().as_str().to_owned(), + wallet_id: context.wallet_id.clone(), + }; + ksp_logging_lib::info!(target: crate::TRACING_TARGET, domain = crate::TRACING_DOMAIN_TRANSPORT, wallet_id = context.wallet_id.as_str(), capability = context.capability, lamports, slot = dto.slot, "Wallet balance refresh succeeded"); + return std::result::Result::Ok(dto); + } + + fn authorized_balance_context(&self) -> ksp_core_lib::Result { + let session = self.wallet_session.lock(); + let session = match session { + std::result::Result::Ok(value) => value, + std::result::Result::Err(_) => return std::result::Result::Err(session_lock_error()), + }; + return match &*session { + crate::WalletSession::View { wallet_id, wallet, .. } => { + std::result::Result::Ok(WalletBalanceContext { capability: "view", pubkey: wallet.pubkey().to_owned(), wallet_id: wallet_id.clone() }) + }, + crate::WalletSession::Owner { wallet_id, wallet, .. } => { + std::result::Result::Ok(WalletBalanceContext { capability: "owner", pubkey: wallet.pubkey().to_owned(), wallet_id: wallet_id.clone() }) + }, + crate::WalletSession::PrivilegedOperation { .. } => std::result::Result::Err(ksp_core_lib::Error::new( + crate::ERROR_CODE_WALLET_SESSION_INVALID, + "Wallet balance is unavailable while a privileged Wallet operation is running", + )), + crate::WalletSession::Locked { .. } | crate::WalletSession::NoSelection => std::result::Result::Err(ksp_core_lib::Error::new( + crate::ERROR_CODE_WALLET_AUTHORIZATION_REQUIRED, + "Wallet balance requires an authorized VIEW or OWNER session", + )), + }; + } + + fn balance_context_is_current(&self, context: &WalletBalanceContext) -> bool { + let session = self.wallet_session.lock(); + let session = match session { + std::result::Result::Ok(value) => value, + std::result::Result::Err(_) => return false, + }; + return match &*session { + crate::WalletSession::View { wallet_id, wallet, .. } => { + context.capability == "view" && wallet_id == &context.wallet_id && wallet.pubkey() == &context.pubkey + }, + crate::WalletSession::Owner { wallet_id, wallet, .. } => { + context.capability == "owner" && wallet_id == &context.wallet_id && wallet.pubkey() == &context.pubkey + }, + crate::WalletSession::NoSelection | crate::WalletSession::Locked { .. } | crate::WalletSession::PrivilegedOperation { .. } => false, + }; + } + /// Returns the resolved common splash timings captured during bootstrap. #[must_use] pub(crate) const fn splash_settings(&self) -> crate::SplashSettings { @@ -562,6 +670,24 @@ fn configured_secret_missing_error() -> ksp_core_lib::Error { return ksp_core_lib::Error::new(crate::ERROR_CODE_WALLET_SECRET_CANDIDATES_MISSING, "No effective Config-owned Wallet password candidate is available"); } +struct WalletBalanceContext { + capability: &'static str, + pubkey: ksp_core_lib::Pubkey, + wallet_id: String, +} + +fn count_to_u32(value: usize, label: &'static str) -> ksp_core_lib::Result { + let converted = u32::try_from(value); + return match converted { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(error) => std::result::Result::Err( + ksp_core_lib::Error::new(crate::ERROR_CODE_APP_STATE_INVALID, "Wallet Desk runtime count exceeds DTO range") + .with_context("count_kind", label) + .with_source(error), + ), + }; +} + struct LoggingRuntimeState { guard: ksp_logging_lib::LoggingGuard, active_profile_id: std::option::Option, diff --git a/crates/ksp-app-wallet-desk/src/constants.rs b/crates/ksp-app-wallet-desk/src/constants.rs index 3801355..dfdd9a7 100644 --- a/crates/ksp-app-wallet-desk/src/constants.rs +++ b/crates/ksp-app-wallet-desk/src/constants.rs @@ -1,5 +1,5 @@ // file: crates/ksp-app-wallet-desk/src/constants.rs -// version: 5 +// version: 6 //! Logging targets, domains and composite component identifiers owned by Wallet Desk. @@ -15,6 +15,8 @@ pub(crate) const TRACING_DOMAIN_BOOTSTRAP: &str = "wallet.bootstrap"; pub(crate) const TRACING_DOMAIN_FRONTEND: &str = "frontend"; /// Structured domain used by the Wallet Desk shell. pub(crate) const TRACING_DOMAIN_SHELL: &str = "wallet.shell"; +/// Structured domain used by Wallet Desk HTTP Transport and balance operations. +pub(crate) const TRACING_DOMAIN_TRANSPORT: &str = "wallet.transport"; /// Structured domain used while preparing Wallet filesystem roots. pub(crate) const TRACING_DOMAIN_WALLET_CONFIG: &str = "wallet.config"; /// Structured domain used while enumerating and inspecting locked Wallet files. diff --git a/crates/ksp-app-wallet-desk/src/dto_common.rs b/crates/ksp-app-wallet-desk/src/dto_common.rs index 2126e66..4eff7cb 100644 --- a/crates/ksp-app-wallet-desk/src/dto_common.rs +++ b/crates/ksp-app-wallet-desk/src/dto_common.rs @@ -1,5 +1,5 @@ // file: crates/ksp-app-wallet-desk/src/dto_common.rs -// version: 3 +// version: 4 //! Common Tauri DTOs shared by Wallet Desk shell commands. @@ -41,6 +41,8 @@ pub(crate) struct RuntimeStatusDto { pub(crate) active_composite_profile: String, /// Active configured Logging profile, or `None` while the transient fallback runtime is active. pub(crate) active_logging_profile: std::option::Option, + /// Standard Transport profile selected by the active composite. + pub(crate) active_transport_profile: String, /// Standard Wallet profile selected by the active composite. pub(crate) active_wallet_profile: String, /// Number of logical Config resources registered by the current application runtime. @@ -57,6 +59,16 @@ pub(crate) struct RuntimeStatusDto { pub(crate) shell_phase: String, /// Safe startup diagnostic that caused fallback Logging, when applicable. pub(crate) startup_diagnostic: std::option::Option, + /// Number of Transport endpoints currently eligible for normal routing. + pub(crate) transport_available_endpoint_count: u32, + /// Safe cluster labels configured by the selected Transport profile. + pub(crate) transport_clusters: std::vec::Vec, + /// Total number of configured Transport endpoints. + pub(crate) transport_endpoint_count: u32, + /// Safe provider labels configured by the selected Transport profile. + pub(crate) transport_providers: std::vec::Vec, + /// Logical Transport role used by Wallet Desk balance reads. + pub(crate) transport_role: String, /// Resolved global Wallet root configured by `cfg.std.wallet`. pub(crate) wallets_directory: String, /// Optional profile-relative Wallet subdirectory selected by the active composite. diff --git a/crates/ksp-app-wallet-desk/src/errors.rs b/crates/ksp-app-wallet-desk/src/errors.rs index f351ff1..b5e14ba 100644 --- a/crates/ksp-app-wallet-desk/src/errors.rs +++ b/crates/ksp-app-wallet-desk/src/errors.rs @@ -1,5 +1,5 @@ // file: crates/ksp-app-wallet-desk/src/errors.rs -// version: 5 +// version: 6 //! Application-local error codes for Wallet Desk composition and desktop runtime surfaces. @@ -26,6 +26,9 @@ pub(crate) const ERROR_CODE_TAURI_WINDOW_MISSING: ksp_core_lib::ErrorCode = ksp_ /// A Tauri window show/focus/destroy/event operation failed. pub(crate) const ERROR_CODE_TAURI_WINDOW_OPERATION_FAILED: ksp_core_lib::ErrorCode = ksp_core_lib::ErrorCode::new("wallet_desk", "tauri_window_operation_failed"); +/// A Wallet balance request requires an authorized VIEW or OWNER session. +pub(crate) const ERROR_CODE_WALLET_AUTHORIZATION_REQUIRED: ksp_core_lib::ErrorCode = + ksp_core_lib::ErrorCode::new("wallet_desk", "wallet_authorization_required"); /// The configured Wallet root or effective profile directory resolves to an unsupported filesystem object. pub(crate) const ERROR_CODE_WALLET_DIRECTORY_INVALID: ksp_core_lib::ErrorCode = ksp_core_lib::ErrorCode::new("wallet_desk", "wallet_directory_invalid"); /// Wallet Desk could not inspect or create the configured Wallet directory tree. diff --git a/crates/ksp-app-wallet-desk/src/lib.rs b/crates/ksp-app-wallet-desk/src/lib.rs index 5c51084..696ebad 100644 --- a/crates/ksp-app-wallet-desk/src/lib.rs +++ b/crates/ksp-app-wallet-desk/src/lib.rs @@ -1,5 +1,5 @@ // file: crates/ksp-app-wallet-desk/src/lib.rs -// version: 6 +// version: 7 //! Tauri desktop application shell for KSP Wallet management and inspection. @@ -16,8 +16,10 @@ mod frontend_logging; mod logging_runtime; mod splash; mod tauri; +mod transport_runtime; mod tw_main; mod tw_splash; +mod wallet_balance; mod wallet_config; mod wallet_inventory; mod wallet_secrets; @@ -50,6 +52,8 @@ pub(crate) use self::constants::TRACING_DOMAIN_BOOTSTRAP; pub(crate) use self::constants::TRACING_DOMAIN_FRONTEND; /// Structured domain used by the Wallet Desk shell. pub(crate) use self::constants::TRACING_DOMAIN_SHELL; +/// Structured domain used by Wallet Desk HTTP Transport and balance operations. +pub(crate) use self::constants::TRACING_DOMAIN_TRANSPORT; /// Structured domain used while preparing Wallet filesystem roots. pub(crate) use self::constants::TRACING_DOMAIN_WALLET_CONFIG; /// Structured domain used while enumerating and inspecting locked Wallet files. @@ -96,6 +100,8 @@ pub(crate) use self::errors::ERROR_CODE_TAURI_RUNTIME_FAILED; pub(crate) use self::errors::ERROR_CODE_TAURI_WINDOW_MISSING; /// A Tauri window show/focus/destroy/event operation failed. pub(crate) use self::errors::ERROR_CODE_TAURI_WINDOW_OPERATION_FAILED; +/// Wallet balance access requires an authorized VIEW or OWNER session. +pub(crate) use self::errors::ERROR_CODE_WALLET_AUTHORIZATION_REQUIRED; /// The configured Wallet root or effective profile directory resolves to an unsupported filesystem object. pub(crate) use self::errors::ERROR_CODE_WALLET_DIRECTORY_INVALID; /// Wallet Desk could not inspect or create the configured Wallet directory tree. @@ -120,6 +126,10 @@ pub(crate) use self::logging_runtime::launch_identity; pub(crate) use self::splash::SplashOrderDto; /// Runtime timings used by the common desk splash lifecycle. pub(crate) use self::splash::SplashSettings; +/// Safe and executable Transport runtime retained by the application state. +pub(crate) use self::transport_runtime::TransportRuntime; +/// Resolves the composite-selected Transport profile and builds the executable HTTP pool. +pub(crate) use self::transport_runtime::initialize_transport; /// Resolves the required main window or returns a typed error. pub(crate) use self::tw_main::require_main_window; /// Shows and focuses the main Wallet Desk window. @@ -128,6 +138,10 @@ pub(crate) use self::tw_main::show_main_window; pub(crate) use self::tw_splash::require_splash_window; /// Starts the one-shot splash lifecycle after the splash frontend reports readiness. pub(crate) use self::tw_splash::splash_frontend_ready_service; +/// Safe balance snapshot for the currently authorized Wallet. +pub(crate) use self::wallet_balance::WalletBalanceDto; +/// Formats exact lamports as a decimal SOL string without floating point. +pub(crate) use self::wallet_balance::format_lamports_as_sol; /// Resolved Wallet Config and directory preparation status captured during application bootstrap. pub(crate) use self::wallet_config::WalletConfigStartup; /// Resolves the composite-selected Wallet Config and prepares its application-owned directory tree. diff --git a/crates/ksp-app-wallet-desk/src/tauri.rs b/crates/ksp-app-wallet-desk/src/tauri.rs index c659f19..2317778 100644 --- a/crates/ksp-app-wallet-desk/src/tauri.rs +++ b/crates/ksp-app-wallet-desk/src/tauri.rs @@ -1,5 +1,5 @@ // file: crates/ksp-app-wallet-desk/src/tauri.rs -// version: 4 +// version: 5 //! Tauri runtime assembly for the KSP wallet desktop application. @@ -44,6 +44,7 @@ fn configure_commands(builder: tauri::Builder) -> tauri::Builder) -> std::result:: }; } +#[tauri::command] +async fn refresh_wallet_balance(state: tauri::State<'_, crate::AppState>) -> std::result::Result { + let result = state.refresh_wallet_balance().await; + return match result { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(error) => std::result::Result::Err(crate::CommandErrorDto::from_error(&error)), + }; +} + #[tauri::command] async fn list_wallets(state: tauri::State<'_, crate::AppState>) -> std::result::Result, crate::CommandErrorDto> { let root = state.wallet_inventory_root().to_path_buf(); diff --git a/crates/ksp-app-wallet-desk/src/transport_runtime.rs b/crates/ksp-app-wallet-desk/src/transport_runtime.rs new file mode 100644 index 0000000..2baa10c --- /dev/null +++ b/crates/ksp-app-wallet-desk/src/transport_runtime.rs @@ -0,0 +1,97 @@ +// file: crates/ksp-app-wallet-desk/src/transport_runtime.rs +// version: 1 + +//! Composite-selected HTTP Transport runtime owned by Wallet Desk. + +/// Safe and executable Transport runtime retained by the application state. +pub(crate) struct TransportRuntime { + pool: ksp_onchain_transport_lib::HttpTransportPool, + profile_id: String, + role: ksp_onchain_transport_lib::HttpRoleName, +} + +impl TransportRuntime { + /// Returns the shareable HTTP Transport pool. + #[must_use] + pub(crate) const fn pool(&self) -> &ksp_onchain_transport_lib::HttpTransportPool { + return &self.pool; + } + + /// Returns the composite-selected Transport profile identifier. + #[must_use] + pub(crate) fn profile_id(&self) -> &str { + return self.profile_id.as_str(); + } + + /// Returns the logical role used by Wallet Desk read-only RPC calls. + #[must_use] + pub(crate) const fn role(&self) -> &ksp_onchain_transport_lib::HttpRoleName { + return &self.role; + } + + /// Returns safe configured cluster labels without endpoint URLs. + #[must_use] + pub(crate) fn clusters(&self) -> std::vec::Vec { + let mut values = self.pool.snapshot().endpoints().iter().map(|endpoint| return endpoint.cluster().to_owned()).collect::>(); + values.sort(); + values.dedup(); + return values; + } + + /// Returns safe configured provider labels without endpoint URLs. + #[must_use] + pub(crate) fn providers(&self) -> std::vec::Vec { + let mut values = self.pool.snapshot().endpoints().iter().map(|endpoint| return endpoint.provider().to_owned()).collect::>(); + values.sort(); + values.dedup(); + return values; + } +} + +/// Resolves the composite-selected Transport profile and builds the executable HTTP pool. +pub(crate) fn initialize_transport(management: &ksp_config_lib::ConfigManagement) -> ksp_core_lib::Result { + let environment = ksp_config_lib::ConfigEnvironment::load(); + let environment = match environment { + std::result::Result::Ok(value) => value, + std::result::Result::Err(error) => return std::result::Result::Err(error), + }; + let composite = crate::load_wallet_desk_composite(management); + let composite = match composite { + std::result::Result::Ok(value) => value, + std::result::Result::Err(error) => return std::result::Result::Err(error), + }; + let profile = crate::required_composite_component_profile(&composite, crate::COMPOSITE_COMPONENT_ID_TRANSPORT, ksp_config_lib::FILE_ID_STD_TRANSPORT); + let profile = match profile { + std::result::Result::Ok(value) => value, + std::result::Result::Err(error) => return std::result::Result::Err(error), + }; + let resolved = management.engine().resolve_transport_config_profile(&profile, &environment); + let resolved = match resolved { + std::result::Result::Ok(value) => value, + std::result::Result::Err(error) => return std::result::Result::Err(error), + }; + let profile_id = resolved.profile_id().to_owned(); + let pool = ksp_onchain_transport_lib::HttpTransportPool::new(resolved.into_settings()); + let pool = match pool { + std::result::Result::Ok(value) => value, + std::result::Result::Err(error) => return std::result::Result::Err(error), + }; + let role = ksp_onchain_transport_lib::HttpRoleName::new("default"); + let descriptor = ksp_onchain_transport_lib::find_http_rpc_method("getBalance"); + let descriptor = match descriptor { + std::option::Option::Some(value) => value, + std::option::Option::None => { + return std::result::Result::Err(ksp_core_lib::Error::new( + crate::ERROR_CODE_APP_STATE_INVALID, + "Wallet Desk Transport registry does not expose getBalance", + )); + }, + }; + let selection = pool.select_for_method(&role, descriptor); + if let std::result::Result::Err(error) = selection { + return std::result::Result::Err(error); + } + let snapshot = pool.snapshot(); + ksp_logging_lib::info!(target: crate::TRACING_TARGET, domain = crate::TRACING_DOMAIN_TRANSPORT, transport_profile = profile_id.as_str(), transport_role = role.as_str(), endpoint_count = snapshot.endpoint_count(), available_endpoint_count = snapshot.available_endpoint_count(), "initialized Wallet Desk HTTP Transport from composite-managed configuration"); + return std::result::Result::Ok(TransportRuntime { pool, profile_id, role }); +} diff --git a/crates/ksp-app-wallet-desk/src/wallet_balance.rs b/crates/ksp-app-wallet-desk/src/wallet_balance.rs new file mode 100644 index 0000000..3465869 --- /dev/null +++ b/crates/ksp-app-wallet-desk/src/wallet_balance.rs @@ -0,0 +1,39 @@ +// file: crates/ksp-app-wallet-desk/src/wallet_balance.rs +// version: 1 + +//! Safe Wallet balance projection produced by the typed HTTP Transport path. + +use ts_rs::TS; // rust-rules: trait-import + +/// Safe balance snapshot for the currently authorized Wallet. +#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize, TS)] +#[serde(rename_all = "camelCase")] +#[ts(export, export_to = "../frontend/ts/bindings/ksp_app_wallet_desk/wallet_balance/WalletBalanceDto.ts")] +pub(crate) struct WalletBalanceDto { + /// Optional Solana RPC API version reported by the selected node. + pub(crate) api_version: std::option::Option, + /// Exact decimal account balance in lamports, encoded as text to avoid JavaScript integer precision loss. + pub(crate) lamports: String, + /// RPC context slot associated with this balance. + pub(crate) slot: u64, + /// Exact decimal SOL presentation derived from lamports without floating point. + pub(crate) sol: String, + /// Composite-selected Transport profile used for the RPC. + pub(crate) transport_profile: String, + /// Logical Transport role used for the RPC. + pub(crate) transport_role: String, + /// Root-scoped Wallet identifier whose authorized Pubkey was queried. + pub(crate) wallet_id: String, +} + +/// Formats exact lamports as a decimal SOL string with nine fractional digits. +#[must_use] +pub(crate) fn format_lamports_as_sol(lamports: u64) -> String { + let whole = lamports / 1_000_000_000; + let fractional = lamports % 1_000_000_000; + return format!("{whole}.{fractional:09}"); +} + +#[cfg(test)] +#[path = "../unit_tests/wallet_balance.rs"] +mod tests; diff --git a/crates/ksp-app-wallet-desk/tauri.conf.json b/crates/ksp-app-wallet-desk/tauri.conf.json index a240e57..56c4b3d 100644 --- a/crates/ksp-app-wallet-desk/tauri.conf.json +++ b/crates/ksp-app-wallet-desk/tauri.conf.json @@ -1,7 +1,7 @@ { "$schema": "https://schema.tauri.app/config/2", "productName": "KSP Wallet Desk", - "version": "0.2.6-pre.6.fix.1", + "version": "0.2.6-pre.7", "identifier": "com.sasedev.ksp-app-wallet-desk", "build": { "beforeDevCommand": "npm run dev", diff --git a/crates/ksp-app-wallet-desk/tests/config_composition.rs b/crates/ksp-app-wallet-desk/tests/config_composition.rs index d9d7c15..4e4cd8e 100644 --- a/crates/ksp-app-wallet-desk/tests/config_composition.rs +++ b/crates/ksp-app-wallet-desk/tests/config_composition.rs @@ -1,5 +1,5 @@ // file: crates/ksp-app-wallet-desk/tests/config_composition.rs -// version: 4 +// version: 5 //! Config composition contracts introduced for Wallet Desk pre.003. @@ -119,3 +119,51 @@ fn assert_component(composite: &ksp_config_lib::ResolvedConfigComposite, compone assert_eq!(component.resolved().selection_source(), ksp_config_lib::ConfigProfileSelectionSource::Composite); } } + +#[test] +fn wallet_desk_composite_transport_profile_builds_get_balance_pool() { + let engine = workspace_engine(); + assert!(engine.is_ok(), "workspace Config engine should be constructible: {engine:?}"); + let engine = match engine { + std::result::Result::Ok(value) => value, + std::result::Result::Err(_) => return, + }; + let file_id = ksp_config_lib::ConfigFileId::new(ksp_config_lib::FILE_ID_COMPOSITE_KSP_APP_WALLET_DESK); + assert!(file_id.is_ok()); + let file_id = match file_id { + std::result::Result::Ok(value) => value, + std::result::Result::Err(_) => return, + }; + let composite = engine.load_resolved_composite(&file_id, std::option::Option::None); + assert!(composite.is_ok(), "committed Wallet Desk composite should resolve: {composite:?}"); + let composite = match composite { + std::result::Result::Ok(value) => value, + std::result::Result::Err(_) => return, + }; + let component = composite.component("transport"); + assert!(component.is_some()); + let component = match component { + std::option::Option::Some(value) => value, + std::option::Option::None => return, + }; + let environment = ksp_config_lib::ConfigEnvironment::from_maps(std::collections::BTreeMap::new(), std::collections::BTreeMap::new()); + let resolved = engine.resolve_transport_config_profile(component.resolved(), &environment); + assert!(resolved.is_ok(), "composite-selected Transport should map: {resolved:?}"); + let resolved = match resolved { + std::result::Result::Ok(value) => value, + std::result::Result::Err(_) => return, + }; + assert_eq!(resolved.selection_source(), ksp_config_lib::ConfigProfileSelectionSource::Composite); + let pool = ksp_onchain_transport_lib::HttpTransportPool::new(resolved.into_settings()); + assert!(pool.is_ok(), "mapped Transport settings should construct a pool"); + let pool = match pool { + std::result::Result::Ok(value) => value, + std::result::Result::Err(_) => return, + }; + let descriptor = ksp_onchain_transport_lib::find_http_rpc_method("getBalance"); + assert!(descriptor.is_some()); + if let std::option::Option::Some(descriptor) = descriptor { + let selection = pool.select_for_method(&ksp_onchain_transport_lib::HttpRoleName::new("default"), descriptor); + assert!(selection.is_ok(), "getBalance should route through the composite-selected Transport pool: {selection:?}"); + } +} diff --git a/crates/ksp-app-wallet-desk/tests/desktop_contract.rs b/crates/ksp-app-wallet-desk/tests/desktop_contract.rs index fcac490..f5276e8 100644 --- a/crates/ksp-app-wallet-desk/tests/desktop_contract.rs +++ b/crates/ksp-app-wallet-desk/tests/desktop_contract.rs @@ -1,5 +1,5 @@ // file: crates/ksp-app-wallet-desk/tests/desktop_contract.rs -// version: 6 +// version: 7 //! Desktop build, shell and Config-status contract audits for Wallet Desk. @@ -172,3 +172,29 @@ fn pre_006_unlock_surface_is_explicit_backend_owned_and_supports_view_owner() { assert!(main.contains("beginFrontendUnlock")); assert!(main.contains("configuredSecretCandidateCount")); } + +#[test] +fn pre_007_balance_uses_authorized_pubkey_and_composite_transport() { + let root = app_root(); + let manifest = read_text(root.join("Cargo.toml").as_path()); + let state = read_text(root.join("src/app_state.rs").as_path()); + let transport = read_text(root.join("src/transport_runtime.rs").as_path()); + let balance = read_text(root.join("src/wallet_balance.rs").as_path()); + let tauri = read_text(root.join("src/tauri.rs").as_path()); + let html = read_text(root.join("frontend/main.html").as_path()); + let main = read_text(root.join("frontend/ts/main.ts").as_path()); + assert!(manifest.contains("ksp-onchain-transport-lib = { path = \"../ksp-onchain-transport-lib\" }")); + assert!(transport.contains("resolve_transport_config_profile")); + assert!(transport.contains("HttpTransportPool::new")); + assert!(transport.contains("getBalance")); + assert!(state.contains("get_balance")); + assert!(state.contains("SolanaCommitment::Confirmed")); + assert!(state.contains("wallet.pubkey()")); + assert!(balance.contains("WalletBalanceDto")); + assert!(balance.contains("format_lamports_as_sol")); + assert!(tauri.contains("refresh_wallet_balance")); + assert!(html.contains("id=\"refreshWalletBalance\"")); + assert!(html.contains("id=\"detailsBalanceLamports\"")); + assert!(main.contains("renderWalletBalance")); + assert!(main.contains("refresh_wallet_balance")); +} diff --git a/crates/ksp-app-wallet-desk/tests/desktop_security.rs b/crates/ksp-app-wallet-desk/tests/desktop_security.rs index 591d7de..9ab5cc5 100644 --- a/crates/ksp-app-wallet-desk/tests/desktop_security.rs +++ b/crates/ksp-app-wallet-desk/tests/desktop_security.rs @@ -1,5 +1,5 @@ // file: crates/ksp-app-wallet-desk/tests/desktop_security.rs -// version: 6 +// version: 7 //! Static desktop security contracts for the Wallet Desk pre.002 shell. @@ -102,3 +102,27 @@ fn wallet_selection_does_not_auto_unlock_configured_secrets() { assert!(!selection.contains("unlock_wallet_view_configured")); assert!(!selection.contains("unlock_wallet_owner_configured")); } + +#[test] +fn balance_refresh_never_accepts_pubkey_or_endpoint_url_from_frontend() { + let root = app_root(); + let state = read_text(root.join("src/app_state.rs").as_path()); + let tauri = read_text(root.join("src/tauri.rs").as_path()); + let main = read_text(root.join("frontend/ts/main.ts").as_path()); + let command_start = tauri.find("async fn refresh_wallet_balance"); + assert!(command_start.is_some()); + let command = &tauri[command_start.unwrap_or_default()..]; + let command = command.split("#[tauri::command]").next().unwrap_or_default(); + assert!(!command.contains("request:")); + assert!(!command.contains("pubkey")); + let refresh_start = main.find("async function refreshWalletBalance"); + let refresh_end = main.find("function bindBalanceActions"); + assert!(refresh_start.is_some()); + assert!(refresh_end.is_some()); + let refresh = &main[refresh_start.unwrap_or_default()..refresh_end.unwrap_or(main.len())]; + assert!(refresh.contains("refresh_wallet_balance")); + assert!(!refresh.contains("pubkey")); + assert!(!main.contains("transportUrl")); + assert!(!main.contains("endpointUrl")); + assert!(state.contains("wallet.pubkey()")); +} diff --git a/crates/ksp-app-wallet-desk/unit_tests/wallet_balance.rs b/crates/ksp-app-wallet-desk/unit_tests/wallet_balance.rs new file mode 100644 index 0000000..fcbf4ff --- /dev/null +++ b/crates/ksp-app-wallet-desk/unit_tests/wallet_balance.rs @@ -0,0 +1,13 @@ +// file: crates/ksp-app-wallet-desk/unit_tests/wallet_balance.rs +// version: 1 + +//! Unit tests for exact Wallet balance presentation. + +#[test] +fn lamports_formatting_is_exact_and_uses_nine_fractional_digits() { + assert_eq!(crate::format_lamports_as_sol(0), "0.000000000"); + assert_eq!(crate::format_lamports_as_sol(1), "0.000000001"); + assert_eq!(crate::format_lamports_as_sol(1_000_000_000), "1.000000000"); + assert_eq!(crate::format_lamports_as_sol(1_234_567_890), "1.234567890"); + assert_eq!(crate::format_lamports_as_sol(u64::MAX), "18446744073.709551615"); +} diff --git a/crates/ksp-config-lib/src/transport.rs b/crates/ksp-config-lib/src/transport.rs index 0a88cf2..9bcff72 100644 --- a/crates/ksp-config-lib/src/transport.rs +++ b/crates/ksp-config-lib/src/transport.rs @@ -1,5 +1,5 @@ // file: crates/ksp-config-lib/src/transport.rs -// version: 1 +// version: 2 /// Effective standard HTTP Transport configuration resolved from Config and mapped to the Transport runtime contract. #[derive(Clone, Eq, PartialEq)] @@ -95,6 +95,24 @@ impl crate::ConfigDocumentEngine { }; return resolve_transport_profile(&profile, environment); } + + /// Maps an already resolved standard Transport profile to the runtime HTTP Transport adapter while preserving its selection provenance. + /// + /// This entry point is intended for profiles selected by a composite. The profile must reference `cfg.std.transport`. + pub fn resolve_transport_config_profile( + &self, + profile: &crate::ResolvedConfigProfile, + environment: &crate::ConfigEnvironment, + ) -> ksp_core_lib::Result { + if profile.file_id().as_str() != crate::FILE_ID_STD_TRANSPORT { + return std::result::Result::Err(effective_error(profile, "resolved Config profile does not reference the standard Transport document")); + } + let descriptor = self.registry().descriptor(profile.file_id()); + if let std::result::Result::Err(error) = descriptor { + return std::result::Result::Err(error); + } + return resolve_transport_profile(profile, environment); + } } #[derive(serde::Deserialize)] diff --git a/crates/ksp-config-lib/tests/public_api.rs b/crates/ksp-config-lib/tests/public_api.rs index 5684529..1af0b1f 100644 --- a/crates/ksp-config-lib/tests/public_api.rs +++ b/crates/ksp-config-lib/tests/public_api.rs @@ -1,5 +1,5 @@ // file: crates/ksp-config-lib/tests/public_api.rs -// version: 19 +// version: 20 //! Integration tests for the public `ksp-config-lib` bootstrap, registry, JSON/profile/composite, environment-resolution, sensitivity, //! Logging/Transport adapters and management contracts. @@ -250,6 +250,7 @@ fn management_contracts_are_available_from_crate_root() { #[test] fn transport_adapter_contract_is_available_from_crate_root() { let _loader = ksp_config_lib::ConfigDocumentEngine::load_resolved_transport_config; + let _composite_loader = ksp_config_lib::ConfigDocumentEngine::resolve_transport_config_profile; assert!(std::mem::size_of::() > 0); assert_eq!(ksp_config_lib::FILE_ID_STD_TRANSPORT, "cfg.std.transport"); assert_eq!(ksp_config_lib::FILE_ID_SCHEMA_STD_TRANSPORT, "schema.std.transport"); diff --git a/crates/ksp-config-lib/unit_tests/transport.rs b/crates/ksp-config-lib/unit_tests/transport.rs index d1dd769..6f78957 100644 --- a/crates/ksp-config-lib/unit_tests/transport.rs +++ b/crates/ksp-config-lib/unit_tests/transport.rs @@ -1,5 +1,5 @@ // file: crates/ksp-config-lib/unit_tests/transport.rs -// version: 1 +// version: 2 #[test] fn fixture_transport_profile_maps_complete_runtime_contract() { @@ -89,6 +89,40 @@ fn transport_profile_preserves_global_and_profile_origin() { } } +#[test] +fn composite_selected_transport_profile_preserves_composite_provenance() { + let engine = committed_engine(); + let engine = match engine { + std::result::Result::Ok(value) => value, + std::result::Result::Err(_) => return, + }; + let composite_file_id = crate::ConfigFileId::new(crate::FILE_ID_COMPOSITE_KSP_APP_WALLET_DESK); + let composite_file_id = match composite_file_id { + std::result::Result::Ok(value) => value, + std::result::Result::Err(_) => return, + }; + let composite = engine.load_resolved_composite(&composite_file_id, std::option::Option::None); + assert!(composite.is_ok(), "committed Wallet Desk composite should resolve: {composite:?}"); + let composite = match composite { + std::result::Result::Ok(value) => value, + std::result::Result::Err(_) => return, + }; + let component = composite.component("transport"); + assert!(component.is_some(), "Wallet Desk composite should contain Transport"); + let component = match component { + std::option::Option::Some(value) => value, + std::option::Option::None => return, + }; + let environment = crate::ConfigEnvironment::from_maps(std::collections::BTreeMap::new(), std::collections::BTreeMap::new()); + let resolved = engine.resolve_transport_config_profile(component.resolved(), &environment); + assert!(resolved.is_ok(), "composite-selected Transport profile should map: {resolved:?}"); + if let std::result::Result::Ok(resolved) = resolved { + assert_eq!(resolved.profile_id(), "devnet_public"); + assert_eq!(resolved.selection_source(), crate::ConfigProfileSelectionSource::Composite); + assert_eq!(resolved.settings().endpoints()[0].cluster().as_str(), "devnet"); + } +} + #[test] fn secret_transport_url_is_runtime_available_but_safe_projection_is_redacted() { let engine = fixture_engine(); diff --git a/deltas/0.2.6/pre.007.md b/deltas/0.2.6/pre.007.md new file mode 100644 index 0000000..9cbf0c1 --- /dev/null +++ b/deltas/0.2.6/pre.007.md @@ -0,0 +1,243 @@ + + + +# Delta `0.2.6-pre.007` — identité autorisée + balance HTTP + +## Base requise + +```text +0.2.6-pre.006-fix.001 appliquée +workspace.package.version = 0.2.6-pre.6.fix.1 +``` + +Le checkpoint opérateur de `pre.006-fix.001` est entièrement vert : formatage, audit structurel, `cargo check`, Clippy, tests Wallet Desk, workspace complet et `cargo tauri dev`. Les quatre chemins d'unlock VIEW/OWNER manuel/configuré ont été vérifiés en runtime. + +## Type de livraison + +```text +ksp-general-0.2.6-pre.007.zip +``` + +Cette tranche modifie Config, le runtime Wallet Desk et le frontend. Le signal technique devient : + +```text +workspace.package.version = 0.2.6-pre.7 +commit = v0.2.6-pre.007 +``` + +Aucun tag stable. + +## Objet + +Fermer le MVP obligatoire de Wallet Desk en composant réellement : + +```text +Config composite +-> Wallet VIEW/OWNER autorisé +-> Pubkey Rust-only comme source RPC +-> HttpTransportPool +-> getBalance +-> balance sûre frontend +``` + +Aucun nouveau wrapper HTTP n'est ajouté : `ksp-onchain-transport-lib::HttpTransportPool::get_balance` est réutilisé directement. + +## Config -> Transport avec provenance composite + +`ksp-config-lib` ajoute : + +```text +ConfigDocumentEngine::resolve_transport_config_profile +``` + +Cette API est l'équivalent Transport des adapters déjà disponibles pour Logging et Wallet. Elle accepte un `ResolvedConfigProfile` sélectionné par composite, impose `cfg.std.transport`, valide le descriptor et conserve : + +```text +selection_source = Composite +``` + +Wallet Desk ne recharge donc pas `devnet_public` comme une sélection explicite indépendante du composite. + +## Runtime Transport Wallet Desk + +Nouveau module : + +```text +src/transport_runtime.rs +``` + +Au bootstrap : + +```text +cfg.composite.ksp-app-wallet-desk +-> component transport +-> resolve_transport_config_profile +-> HttpTransportPool::new +-> validation locale d'une route getBalance / role default +``` + +Le pool est conservé dans `AppState` et partagé par les refresh de balance. + +Les diagnostics sûrs exposent uniquement : + +```text +transport profile +role = default +cluster(s) +provider(s) +endpoint_count +available_endpoint_count +``` + +Les URLs Transport restent absentes des DTOs/frontend/logs applicatifs. + +## Balance autorisée + +Nouvelle commande : + +```text +refresh_wallet_balance +``` + +Elle ne reçoit **aucun argument frontend**. + +Rust verrouille brièvement `WalletSession`, accepte uniquement : + +```text +View +Owner +``` + +puis copie : + +```text +wallet_id +capability +Pubkey +``` + +Le mutex est libéré avant l'I/O réseau. `Locked`, `NoSelection` et `PrivilegedOperation` ne peuvent pas effectuer le RPC. + +Appel : + +```text +HttpTransportPool::get_balance( + role = default, + pubkey = issue du handle VIEW/OWNER Rust, + commitment = confirmed, +) +``` + +Après l'I/O, le backend vérifie que le même wallet/capability/Pubkey est encore autorisé. Si un Lock, Deselect ou changement de wallet est intervenu entre-temps, la réponse stale est rejetée au lieu d'être reprojetée. + +## `WalletBalanceDto` + +Le nouveau DTO expose : + +```text +wallet_id +lamports decimal string exacte +sol decimal exact à 9 décimales +slot +api_version optionnelle +transport_profile +transport_role +``` + +`lamports` traverse IPC comme chaîne décimale afin d'éviter toute perte de précision JavaScript sur un `u64` supérieur à `Number.MAX_SAFE_INTEGER`. + +La représentation SOL est dérivée sans floating point : + +```text +0 -> 0.000000000 +1 -> 0.000000001 +1_000_000_000 -> 1.000000000 +``` + +## Frontend + +Le Dashboard affiche maintenant les diagnostics Transport sûrs. + +La vue Details devient fonctionnelle après VIEW/OWNER : + +```text +Pubkey +alias +notes +lamports +SOL +RPC slot +RPC api_version +Transport profile / role +Refresh balance +``` + +Le bouton `Refresh balance` reste désactivé tant que la session n'est pas VIEW ou OWNER. + +Lock/Deselect/Refresh inventory/changement de wallet purgent la projection de balance avec les autres données autorisées. + +Le frontend ignore également une réponse de balance qui ne correspond plus au `activeWalletId` courant, en complément de la vérification backend. + +## Tests et canaris + +Ajouts/renforcements : + +```text +Config Transport adapter composite -> provenance Composite +composite Wallet Desk -> HttpTransportPool -> route getBalance +format lamports/SOL exact sans flottant +commande refresh_wallet_balance présente +Pubkey obtenue via wallet.pubkey() côté Rust +commitment confirmed +refresh frontend sans pubkey ni endpoint URL +UI Details / diagnostics Transport présents +``` + +Le smoke réseau réel reste effectué via `cargo tauri dev` avec un wallet VIEW/OWNER autorisé ; aucun wallet financé n'est requis, une réponse `0` lamport est valide. + +## Dépendances + +Wallet Desk consomme maintenant directement la crate KSP interne déjà présente dans le workspace : + +```text +ksp-onchain-transport-lib +``` + +Aucune dépendance tierce Cargo ou npm n'est ajoutée et aucune capability Tauri supplémentaire n'est nécessaire. + +**Aucune commande npm directe n'est nécessaire.** + +## Validation opérateur requise + +```bash +cargo fmt --all +python3 scripts/audit_rust_workspace_rules.py +cargo check --workspace +cargo clippy --workspace --all-targets +cargo test -p ksp-config-lib +cargo test -p ksp-app-wallet-desk +cargo test --workspace + +KSP_WALLETS_DIRECTORY=var/wallet-desk-pre007 \ +cargo tauri dev -c crates/ksp-app-wallet-desk/tauri.conf.json +``` + +Dans l'application : + +```text +créer ou sélectionner un vrai .kspwallet +-> unlock VIEW ou OWNER +-> Details +-> Refresh balance +-> vérifier lamports / SOL / slot / api_version +-> Lock +-> vérifier purge de la balance et bouton désactivé +``` + +Le RPC `getBalance` peut retourner `0` lamport : ce résultat doit être affiché comme un succès normal. + +Toujours aucun `cargo tauri build` à ce stade. + +## Suite + +`pre.008` ajoutera l'import Solana CLI JSON / Base58 avec picker natif minimal, inspection sûre de la source, nouveaux credentials KSP et destination no-clobber sous la racine Wallet effective. diff --git a/docs/plans/002-FUNCTIONAL_RELEASE_SEQUENCE.md b/docs/plans/002-FUNCTIONAL_RELEASE_SEQUENCE.md index c5ce416..e6e4a05 100644 --- a/docs/plans/002-FUNCTIONAL_RELEASE_SEQUENCE.md +++ b/docs/plans/002-FUNCTIONAL_RELEASE_SEQUENCE.md @@ -1,5 +1,5 @@ - + # Séquence des releases fonctionnelles KSP @@ -430,7 +430,7 @@ Le prompt [`../../prompts/011-V0_2_6_START_PROMPT.md`](../../prompts/011-V0_2_6_ `0.2.6-pre.001` confirme que le registre Config doit être étendu pour `cfg.std.wallet`/`schema.std.wallet` et `cfg.composite.ksp-app-wallet-desk`. `wallets_directory` reste global avec fallback `${KSP_WALLETS_DIRECTORY:-wallets}` et chaque profil peut définir un `wallets_subdirectory` relatif pour isoler tests, temporaires ou futurs scénarios. Wallet Desk prépare/crée le répertoire effectif après résolution Config et journalise le succès en debug ou l'échec en error. Le gabarit Config Desk est réutilisé avec Bootstrap, Font Awesome, DataTables/Select, SimpleBar et `resize-observer-polyfill`. L'inventory reste non récursive `.kspwallet`, sans symlink d'entrée et root-scoped; les handles VIEW/OWNER restent exclusivement côté Rust. L'ouverture accepte un password éphémère saisi ou une tentative explicite de secrets Config `KSP_SECRET_WALLET_PASS_*`, dont ni nom ni valeur ne traversent le frontend. `getBalance` utilise la Pubkey du handle autorisé et les flows OWNER metadata/rotations/revocation/export fichier délèguent à Wallet. La CSP reste `null` par défaut comme dans Config Desk et n'est réauditée qu'en présence d'un besoin WebView concret. Le forecast souple détaillé s'étend jusqu'à `pre.014`, dernière tranche prévue pour README/USAGE/docs/validation, prompt `0.2.7` et build Tauri final; le plan actif est `docs/plans/013-V0_2_6_WALLET_DESK_PLAN.md`. -`0.2.6-pre.002` matérialise le shell Tauri spécialisé. `0.2.6-pre.003` matérialise ensuite la première composition Config propre à Wallet Desk : `cfg.std.wallet`/`schema.std.wallet`, le composite `cfg.composite.ksp-app-wallet-desk`, `ResolvedWalletConfig`, la racine `${KSP_WALLETS_DIRECTORY:-wallets}`, les sous-répertoires de profils `temporary`/`tests`, la préservation de provenance `Composite` dans les adapters Logging/Wallet et la création sûre des répertoires par l’application. Aucun inventory ou fichier `.kspwallet` n’est encore ouvert dans cette tranche. `0.2.6-pre.003-fix.001` corrige ensuite les tests de registry/fixtures devenus obsolètes et instrumente les clics frontend génériques sans sérialiser la valeur des contrôles. `0.2.6-pre.003-fix.002` corrige le scanner d’inventaire `.env.example` qui interprétait `FILE_ID_COMPOSITE_KSP_APP_WALLET_DESK` comme une variable d’environnement, remplace le profil Logging ad hoc Wallet Desk par les profils génériques console-only/`file_info`/`superdev`/`supertrace`, et sélectionne temporairement `supertrace` dans le composite Wallet Desk. `0.2.6-pre.003-fix.003` corrige les deux canaris révélés par la validation opérateur de `fix.002` sans modifier cette surface Logging : closures avec `return` explicite sous la politique Clippy KSP et test lexical séparant fragment d’identifiant d’un vrai nom KSP suffixé. `0.2.6-pre.003-fix.004` complète cette remédiation en ajoutant les `return` explicites aux cinq closures restantes du canari `config_composition` de Wallet Desk ; aucune surface Config/Logging/frontend n’est modifiée. `0.2.6-pre.004` ajoute l’inventory `.kspwallet` réel sous `effective_wallets_directory` : lecture non récursive, extension exacte, exclusion des symlinks et non-fichiers, inspection par `ksp-wallet-lib::inspect_locked_wallet_file_v1`, lignes invalides conservées avec diagnostic sûr, DTOs locked sans identité protégée, DataTable/refresh actifs et sélection filename root-scoped revalidée côté Rust. Aucun handle VIEW/OWNER ni password n’est introduit dans cette tranche. `0.2.6-pre.004-fix.001` limite ensuite à `#[cfg(test)]` les deux réexports crate-root internes des enums d’état/inspection, uniquement consommés par les unit tests ; le build runtime ne les importe plus, tandis que les tests conservent le chemin `crate::...` imposé par les règles d’exports KSP. Le contrat runtime et TS-RS reste inchangé. `0.2.6-pre.005` branche ensuite la création native sur `create_wallet_file_v1` et introduit un `WalletSession` durable dans `AppState` : création -> OWNER ouvert, sélection existante -> Locked, puis lock/deselect/refresh/changement de wallet -> drop des handles et purge des projections protégées. Les passwords de création transitent uniquement frontend -> Rust et sont immédiatement déplacés dans les wrappers Wallet ; les unlock de wallets existants restent `pre.006`. `0.2.6-pre.005-fix.001` ferme le premier gate opérateur sans changer ce contrat : `WalletOwner` est boxed dans la variante OWNER pour éviter un `WalletSession` de plus de 1 KiB et le test statique de sécurité initialise correctement son offset `request_start`. `0.2.6-pre.006` matérialise les unlock manuels VIEW/OWNER et les secrets configurés : Config découvre les variables `KSP_SECRET_WALLET_PASS_*`, Wallet Desk ordonne les candidats par filename normalisé puis labels numériques puis nommés, ne révèle chaque valeur qu’au moment d’une tentative explicitement demandée, conserve noms/suffixes/valeurs hors IPC/logs, et protège les KDF concurrents avec `PrivilegedOperation` avant d’installer `WalletView` ou `WalletOwner` uniquement en Rust. `0.2.6-pre.006-fix.001` corrige les deux canaris statiques de `desktop_security` qui recherchaient le token `password` dans toute la définition textuelle de `WalletAuthorizedDto` et confondaient ainsi la documentation sûre de `configured_secret_candidate_count` avec un champ secret ; les assertions sont désormais bornées aux lignes de champs Rust de la projection. +`0.2.6-pre.002` matérialise le shell Tauri spécialisé. `0.2.6-pre.003` matérialise ensuite la première composition Config propre à Wallet Desk : `cfg.std.wallet`/`schema.std.wallet`, le composite `cfg.composite.ksp-app-wallet-desk`, `ResolvedWalletConfig`, la racine `${KSP_WALLETS_DIRECTORY:-wallets}`, les sous-répertoires de profils `temporary`/`tests`, la préservation de provenance `Composite` dans les adapters Logging/Wallet et la création sûre des répertoires par l’application. Aucun inventory ou fichier `.kspwallet` n’est encore ouvert dans cette tranche. `0.2.6-pre.003-fix.001` corrige ensuite les tests de registry/fixtures devenus obsolètes et instrumente les clics frontend génériques sans sérialiser la valeur des contrôles. `0.2.6-pre.003-fix.002` corrige le scanner d’inventaire `.env.example` qui interprétait `FILE_ID_COMPOSITE_KSP_APP_WALLET_DESK` comme une variable d’environnement, remplace le profil Logging ad hoc Wallet Desk par les profils génériques console-only/`file_info`/`superdev`/`supertrace`, et sélectionne temporairement `supertrace` dans le composite Wallet Desk. `0.2.6-pre.003-fix.003` corrige les deux canaris révélés par la validation opérateur de `fix.002` sans modifier cette surface Logging : closures avec `return` explicite sous la politique Clippy KSP et test lexical séparant fragment d’identifiant d’un vrai nom KSP suffixé. `0.2.6-pre.003-fix.004` complète cette remédiation en ajoutant les `return` explicites aux cinq closures restantes du canari `config_composition` de Wallet Desk ; aucune surface Config/Logging/frontend n’est modifiée. `0.2.6-pre.004` ajoute l’inventory `.kspwallet` réel sous `effective_wallets_directory` : lecture non récursive, extension exacte, exclusion des symlinks et non-fichiers, inspection par `ksp-wallet-lib::inspect_locked_wallet_file_v1`, lignes invalides conservées avec diagnostic sûr, DTOs locked sans identité protégée, DataTable/refresh actifs et sélection filename root-scoped revalidée côté Rust. Aucun handle VIEW/OWNER ni password n’est introduit dans cette tranche. `0.2.6-pre.004-fix.001` limite ensuite à `#[cfg(test)]` les deux réexports crate-root internes des enums d’état/inspection, uniquement consommés par les unit tests ; le build runtime ne les importe plus, tandis que les tests conservent le chemin `crate::...` imposé par les règles d’exports KSP. Le contrat runtime et TS-RS reste inchangé. `0.2.6-pre.005` branche ensuite la création native sur `create_wallet_file_v1` et introduit un `WalletSession` durable dans `AppState` : création -> OWNER ouvert, sélection existante -> Locked, puis lock/deselect/refresh/changement de wallet -> drop des handles et purge des projections protégées. Les passwords de création transitent uniquement frontend -> Rust et sont immédiatement déplacés dans les wrappers Wallet ; les unlock de wallets existants restent `pre.006`. `0.2.6-pre.005-fix.001` ferme le premier gate opérateur sans changer ce contrat : `WalletOwner` est boxed dans la variante OWNER pour éviter un `WalletSession` de plus de 1 KiB et le test statique de sécurité initialise correctement son offset `request_start`. `0.2.6-pre.006` matérialise les unlock manuels VIEW/OWNER et les secrets configurés : Config découvre les variables `KSP_SECRET_WALLET_PASS_*`, Wallet Desk ordonne les candidats par filename normalisé puis labels numériques puis nommés, ne révèle chaque valeur qu’au moment d’une tentative explicitement demandée, conserve noms/suffixes/valeurs hors IPC/logs, et protège les KDF concurrents avec `PrivilegedOperation` avant d’installer `WalletView` ou `WalletOwner` uniquement en Rust. `0.2.6-pre.006-fix.001` corrige les deux canaris statiques de `desktop_security` qui recherchaient le token `password` dans toute la définition textuelle de `WalletAuthorizedDto` et confondaient ainsi la documentation sûre de `configured_secret_candidate_count` avec un champ secret ; les assertions sont désormais bornées aux lignes de champs Rust de la projection. `0.2.6-pre.007` ferme le MVP obligatoire Config composite + Wallet + Transport : `resolve_transport_config_profile` préserve la provenance `Composite`, Wallet Desk construit le pool HTTP au bootstrap et valide statiquement une route `getBalance` sur le rôle `default`, puis `refresh_wallet_balance` copie uniquement la Pubkey depuis un handle VIEW/OWNER avant de libérer le mutex session et d'effectuer l'I/O. La réponse expose lamports exacts, SOL formaté sans flottant, slot, `api_version`, profil/rôle Transport ; une complétion devenue stale après lock/deselect/changement de session est rejetée. Les diagnostics Transport restent limités à profile/cluster/provider/compteurs, sans URL. ## `0.2.7` — WebSocket Solana standard diff --git a/docs/plans/013-V0_2_6_WALLET_DESK_PLAN.md b/docs/plans/013-V0_2_6_WALLET_DESK_PLAN.md index c1dc321..879a96f 100644 --- a/docs/plans/013-V0_2_6_WALLET_DESK_PLAN.md +++ b/docs/plans/013-V0_2_6_WALLET_DESK_PLAN.md @@ -1,5 +1,5 @@ - + # Plan `0.2.6` — Wallet Desk @@ -23,7 +23,7 @@ Les validations opérateur du `2026-08-20` ont ensuite confirmé la base `pre.00 `0.2.6-pre.002` matérialise ensuite la première tranche technique : la crate `ksp-app-wallet-desk` rejoint le workspace avec le shell splash/main du gabarit Config Desk, le bootstrap Config + Logging commun, les ports `1432/1433`, Bootstrap, Font Awesome, DataTables/Select, SimpleBar, `resize-observer-polyfill`, TS-RS et le bridge frontend -> Rust -> `ksp-logging-lib`. Cette tranche ne branche encore ni `std.wallet`, ni inventory filesystem réel, ni `ksp-wallet-lib`, ni Transport : ces responsabilités restent dans les prereleases déjà dimensionnées. -`0.2.6-pre.003` matérialise la composition Config prévue : `cfg.std.wallet`/`schema.std.wallet`, le composite `cfg.composite.ksp-app-wallet-desk`, les profils Wallet `default`/`temporary`/`tests`, `ResolvedWalletConfig` et les adapters qui peuvent consommer un profil déjà sélectionné par composite sans perdre la provenance `Composite`. Wallet Desk valide les composants `logging`/`transport`/`wallet`, crée la racine et le sous-répertoire effectif absents avec logs `debug`, refuse les objets filesystem invalides/symlinks de sous-répertoire avec logs `error`, et expose uniquement les chemins/profils non secrets dans le statut runtime. Aucun inventory `.kspwallet` n’est encore effectué. `pre.003-fix.001` corrige les deux régressions de tests révélées par la validation workspace et le warning Clippy, puis rend visibles les événements `trace` frontend. `pre.003-fix.002` corrige ensuite le canari d’inventaire `.env.example` qui confondait un fragment d’identifiant Rust avec une variable KSP, remplace le profil temporaire `wallet_desk_dev` par une famille Logging réutilisable (`console_*`, `file_info`, `superdev`, `supertrace`) et fait sélectionner temporairement `supertrace` par le composite Wallet Desk afin de conserver la visibilité des actions frontend sans profil spécifique à l’application. `pre.003-fix.003` corrige uniquement les canaris révélés par la validation de `fix.002` : conformité `clippy::implicit_return` et séparation explicite entre fragment lexical KSP incorporé dans un identifiant et nom d’environnement concret suffixé. `pre.003-fix.004` ferme le dernier défaut Clippy de cette série en ajoutant les `return` explicites aux cinq closures restantes du test de composition `supertrace`, sans changer les profils Logging ni le composite. `pre.004` matérialise ensuite l’inventory locked réel. Sa validation opérateur confirme le comportement fonctionnel et le workspace complet, mais révèle deux warnings `unused_imports` sur des réexports crate-root internes uniquement utiles aux unit tests ; `pre.004-fix.001` les limite à `#[cfg(test)]` : ils disparaissent du build runtime mais restent disponibles au crate-root pour les unit tests, conformément aux règles d’exports KSP, sans changement de comportement. `pre.005` matérialise ensuite la création native dans Wallet Desk et le premier lifecycle durable `WalletSession` : création no-clobber sous la racine Config via `create_wallet_file_v1`, session OWNER conservée uniquement en Rust après création, sélection locked durable, `Lock`/`Deselect`/Refresh/changement de wallet avec drop des handles et purge frontend des projections protégées/passwords. Les unlock VIEW/OWNER de wallets existants restent strictement `pre.006`. `pre.005-fix.001` corrige le gate de compilation/tests révélé par l'opérateur sans modifier le lifecycle : la variante `WalletSession::Owner` contient désormais `Box` afin de fermer `clippy::large_enum_variant`, et le canari de sécurité définit explicitement `request_start` avant de contrôler les champs password request-only. `pre.006` matérialise ensuite les unlock existants : VIEW/OWNER manuel, découverte Config des candidats `KSP_SECRET_WALLET_PASS_*`, ordre déterministe filename normalisé -> numérique -> nommé, actions configurées explicites et jamais automatiques, `PrivilegedOperation` pendant Argon2, puis sessions `View`/`Owner` Rust-only avec candidate count seul projeté vers l’UI. `pre.006-fix.001` corrige les deux canaris `desktop_security` qui inspectaient trop largement le texte de `WalletAuthorizedDto` : la documentation du compteur de candidats contient légitimement le mot `password`, mais aucun champ password n’est sérialisé ; le test filtre désormais uniquement les lignes de champs `pub(crate)` de la structure. +`0.2.6-pre.003` matérialise la composition Config prévue : `cfg.std.wallet`/`schema.std.wallet`, le composite `cfg.composite.ksp-app-wallet-desk`, les profils Wallet `default`/`temporary`/`tests`, `ResolvedWalletConfig` et les adapters qui peuvent consommer un profil déjà sélectionné par composite sans perdre la provenance `Composite`. Wallet Desk valide les composants `logging`/`transport`/`wallet`, crée la racine et le sous-répertoire effectif absents avec logs `debug`, refuse les objets filesystem invalides/symlinks de sous-répertoire avec logs `error`, et expose uniquement les chemins/profils non secrets dans le statut runtime. Aucun inventory `.kspwallet` n’est encore effectué. `pre.003-fix.001` corrige les deux régressions de tests révélées par la validation workspace et le warning Clippy, puis rend visibles les événements `trace` frontend. `pre.003-fix.002` corrige ensuite le canari d’inventaire `.env.example` qui confondait un fragment d’identifiant Rust avec une variable KSP, remplace le profil temporaire `wallet_desk_dev` par une famille Logging réutilisable (`console_*`, `file_info`, `superdev`, `supertrace`) et fait sélectionner temporairement `supertrace` par le composite Wallet Desk afin de conserver la visibilité des actions frontend sans profil spécifique à l’application. `pre.003-fix.003` corrige uniquement les canaris révélés par la validation de `fix.002` : conformité `clippy::implicit_return` et séparation explicite entre fragment lexical KSP incorporé dans un identifiant et nom d’environnement concret suffixé. `pre.003-fix.004` ferme le dernier défaut Clippy de cette série en ajoutant les `return` explicites aux cinq closures restantes du test de composition `supertrace`, sans changer les profils Logging ni le composite. `pre.004` matérialise ensuite l’inventory locked réel. Sa validation opérateur confirme le comportement fonctionnel et le workspace complet, mais révèle deux warnings `unused_imports` sur des réexports crate-root internes uniquement utiles aux unit tests ; `pre.004-fix.001` les limite à `#[cfg(test)]` : ils disparaissent du build runtime mais restent disponibles au crate-root pour les unit tests, conformément aux règles d’exports KSP, sans changement de comportement. `pre.005` matérialise ensuite la création native dans Wallet Desk et le premier lifecycle durable `WalletSession` : création no-clobber sous la racine Config via `create_wallet_file_v1`, session OWNER conservée uniquement en Rust après création, sélection locked durable, `Lock`/`Deselect`/Refresh/changement de wallet avec drop des handles et purge frontend des projections protégées/passwords. Les unlock VIEW/OWNER de wallets existants restent strictement `pre.006`. `pre.005-fix.001` corrige le gate de compilation/tests révélé par l'opérateur sans modifier le lifecycle : la variante `WalletSession::Owner` contient désormais `Box` afin de fermer `clippy::large_enum_variant`, et le canari de sécurité définit explicitement `request_start` avant de contrôler les champs password request-only. `pre.006` matérialise ensuite les unlock existants : VIEW/OWNER manuel, découverte Config des candidats `KSP_SECRET_WALLET_PASS_*`, ordre déterministe filename normalisé -> numérique -> nommé, actions configurées explicites et jamais automatiques, `PrivilegedOperation` pendant Argon2, puis sessions `View`/`Owner` Rust-only avec candidate count seul projeté vers l’UI. `pre.006-fix.001` corrige les deux canaris `desktop_security` qui inspectaient trop largement le texte de `WalletAuthorizedDto` : la documentation du compteur de candidats contient légitimement le mot `password`, mais aucun champ password n’est sérialisé ; le test filtre désormais uniquement les lignes de champs `pub(crate)` de la structure. `pre.007` ferme ensuite le MVP réseau : Config sait mapper un profil Transport déjà sélectionné par composite sans perdre la provenance `Composite`; Wallet Desk construit et conserve `HttpTransportPool`, publie uniquement profile/role/cluster/provider/compteurs sûrs, et `refresh_wallet_balance` accepte zéro argument frontend. Rust copie la Pubkey depuis `WalletView`/`WalletOwner`, libère le mutex avant l'I/O `getBalance`, utilise `confirmed`, puis projette lamports, SOL exact à neuf décimales, slot et `api_version`. Une réponse arrivée après lock/deselect/changement d'autorisation est refusée afin d'empêcher une balance stale de réapparaître. ## 2. Sources relues et hiérarchie appliquée @@ -1387,19 +1387,22 @@ Le frontend Security expose quatre actions distinctes : VIEW manuel, OWNER manue ### `pre.007` — détails autorisés + balance HTTP -Objectifs : +Statut : **implémenté dans `0.2.6-pre.007`**. ```text -WalletAuthorizedDto -Pubkey / alias / notes -HttpTransportPool depuis composite -getBalance VIEW -getBalance OWNER -lamports + SOL formaté + slot/api_version -refresh manuel -diagnostics Transport sûrs +WalletAuthorizedDto -> Pubkey / alias / notes +Config composite -> ResolvedTransportConfig (selection_source = Composite) +ResolvedTransportConfig -> HttpTransportPool +VIEW/OWNER Rust-only -> Pubkey copiée avant I/O +getBalance(role=default, commitment=confirmed) +-> lamports exacts +-> SOL formaté sans flottant +-> slot / api_version +-> transport profile / role ``` +Le frontend appelle `refresh_wallet_balance` sans argument ; il ne peut donc injecter ni Pubkey ni URL d'endpoint. Les diagnostics exposent seulement profile, rôle, cluster(s), provider(s), total d'endpoints et endpoints disponibles. Lock/Deselect/Refresh/changement de wallet purgent la balance ; le backend revérifie aussi que la session autorisée n'a pas changé pendant l'I/O avant de livrer le résultat. + À ce point le MVP obligatoire est complet : wallet autorisé + identité + balance réseau. ### `pre.008` — import Solana CLI JSON / Base58