Sasedev/khadhroony-solana-project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

v0.2.9-pre.013-fix.004

Browse Source
This commit is contained in:
SinuS von SifriduS
2026-08-24 23:39:11 +02:00
parent 51bcf870d3
commit dcabceb52f
3 changed files with 187 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Cargo.toml
View File

@@ -1,12 +1,12 @@
# file: Cargo.toml
# version: 257
# version: 258
[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.9-pre.13.fix.3"
version = "0.2.9-pre.13.fix.4"
edition = "2024"
license = "MIT"
repository = "https://git.sasedev.com/Sasedev/khadhroony-solana-project"

65
crates/ksp-onchain-transport-lib/tests/yellowstone_publicnode_smoke.rs
View File

@@ -1,5 +1,5 @@
// file: crates/ksp-onchain-transport-lib/tests/yellowstone_publicnode_smoke.rs
// version: 4
// version: 5
//! Opt-in live PublicNode Mainnet/Testnet smokes for authenticated provider-neutral Yellowstone gRPC Subscribe.
@@ -14,7 +14,10 @@ static PUBLICNODE_X_TOKENS: std::sync::OnceLock<PublicNodeTokens> = std::sync::O
fn read_token_line(label: &str) -> std::string::String {
let mut token = std::string::String::new();
std::io::stdin().read_line(&mut token).expect("PublicNode x-token must be readable from smoke stdin");
match std::io::stdin().read_line(&mut token) {
std::result::Result::Ok(_) => {},
std::result::Result::Err(error) => panic!("PublicNode {label} x-token must be readable from smoke stdin: {error}"),
}
let token = token.trim().to_owned();
assert!(!token.is_empty(), "PublicNode {label} x-token provided on smoke stdin must not be empty");
return token;
@@ -58,7 +61,10 @@ fn publicnode_endpoint(
url,
session,
);
let metadata = ksp_onchain_transport_lib::YellowstoneGrpcMetadataEntry::secret("x-token", x_token)?;
let metadata = match ksp_onchain_transport_lib::YellowstoneGrpcMetadataEntry::secret("x-token", x_token) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
return endpoint.with_metadata(vec![metadata]);
}
@@ -68,35 +74,61 @@ fn slot_request() -> ksp_core_lib::Result<ksp_onchain_transport_lib::Yellowstone
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
request.insert_slot_filter(name, ksp_onchain_transport_lib::YellowstoneSubscribeSlotFilter::new())?;
match request.insert_slot_filter(name, ksp_onchain_transport_lib::YellowstoneSubscribeSlotFilter::new()) {
std::result::Result::Ok(()) => {},
std::result::Result::Err(error) => return std::result::Result::Err(error),
}
return std::result::Result::Ok(request);
}
async fn assert_publicnode_slot_stream(name: &str, cluster: &str, url: &str, x_token: &str) {
let endpoint = publicnode_endpoint(name, cluster, url, x_token).expect("programmatic PublicNode Yellowstone settings must accept secret x-token metadata");
let endpoint = match publicnode_endpoint(name, cluster, url, x_token) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => panic!("programmatic PublicNode Yellowstone settings must accept secret x-token metadata: {error:?}"),
};
let endpoint_debug = format!("{endpoint:?}");
assert!(!endpoint_debug.contains(x_token), "PublicNode x-token must not appear in endpoint Debug");
let channel = ksp_onchain_transport_lib::YellowstoneGrpcChannel::connect(&endpoint).await.expect("PublicNode Yellowstone TLS connection must succeed");
let channel = match ksp_onchain_transport_lib::YellowstoneGrpcChannel::connect(&endpoint).await {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => panic!("PublicNode Yellowstone TLS connection must succeed: {error:?}"),
};
assert_eq!(channel.endpoint_name(), name);
assert_eq!(channel.provider().as_str(), "publicnode");
assert_eq!(channel.cluster().as_str(), cluster);
let request = slot_request().expect("PublicNode Yellowstone slot request must be valid");
let mut session = channel.open_standard_subscribe(request).await.expect("PublicNode Yellowstone authenticated Subscribe must open");
let slot = tokio::time::timeout(std::time::Duration::from_secs(20), async {
let request = match slot_request() {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => panic!("PublicNode Yellowstone slot request must be valid: {error:?}"),
};
let mut session = match channel.open_standard_subscribe(request).await {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => panic!("PublicNode Yellowstone authenticated Subscribe must open: {error:?}"),
};
let slot_result = tokio::time::timeout(std::time::Duration::from_secs(20), async {
loop {
match session.next_update().await.expect("PublicNode Yellowstone Subscribe update must decode") {
std::option::Option::Some(ksp_onchain_transport_lib::YellowstoneSubscribeUpdate::Slot(update)) => break update.slot(),
let next_update = match session.next_update().await {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => panic!("PublicNode Yellowstone Subscribe update must decode: {error:?}"),
};
match next_update {
std::option::Option::Some(ksp_onchain_transport_lib::YellowstoneSubscribeUpdate::Slot(update)) => return update.slot(),
std::option::Option::Some(_) => {},
std::option::Option::None => panic!("PublicNode Yellowstone Subscribe ended before a slot update"),
}
}
})
.await
.expect("PublicNode Yellowstone Subscribe must publish a slot update before the smoke deadline");
.await;
let slot = match slot_result {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => panic!("PublicNode Yellowstone Subscribe must publish a slot update before the smoke deadline: {error}"),
};
assert!(slot > 0);
let close_result = tokio::time::timeout(std::time::Duration::from_secs(7), session.close())
.await
.expect("KSP Yellowstone Subscribe close must remain bounded beyond the configured five-second provider half-close deadline");
let close_timeout_result = tokio::time::timeout(std::time::Duration::from_secs(7), session.close()).await;
let close_result = match close_timeout_result {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => {
panic!("KSP Yellowstone Subscribe close must remain bounded beyond the configured five-second provider half-close deadline: {error}")
},
};
match close_result {
std::result::Result::Ok(()) => {},
std::result::Result::Err(error) => {
@@ -107,6 +139,7 @@ async fn assert_publicnode_slot_stream(name: &str, cluster: &str, url: &str, x_t
);
},
}
return;
}
#[tokio::test(flavor = "current_thread")]

136
deltas/0.2.9/pre.013-fix.004.md Normal file
View File

@@ -0,0 +1,136 @@
<!-- file: deltas/0.2.9/pre.013-fix.004.md -->
<!-- version: 1 -->
# Delta `0.2.9-pre.013-fix.004` — conformité Clippy du smoke PublicNode final
## 1. Base
```text
0.2.9-pre.013-fix.003
```
Cette tranche reste strictement dans le couloir technique/live de fin de release. Elle ne modifie ni Config, ni README/USAGE, ni plan/validation, ni CHANGELOG/ROADMAP, ni le prompt de la release suivante.
## 2. Motif opérateur
La validation opérateur de `pre.013-fix.003` confirme le comportement live final du smoke PublicNode :
```text
Mainnet Subscribe + slot PASS
Testnet Subscribe + slot PASS
2 passed / 0 failed
```
Elle confirme aussi :
```text
cargo fmt --all PASS
python3 scripts/audit_rust_workspace_rules.py clean / 0 export candidate / clean
cargo check --workspace PASS
cargo test -p ksp-config-lib 113 unit + 5 ownership + 15 public API PASS
cargo test -p ksp-onchain-transport-lib 383 unit + 49 public API + 43 completeness + 4 doctests PASS
cargo test -p ksp-core-lib --test workspace_dependencies 3/3 PASS
cargo test --workspace PASS
cargo tree -p ksp-onchain-transport-lib exécuté
cargo tree -p ksp-onchain-transport-lib --duplicates exécuté
cargo tree --duplicates exécuté
```
Le seul gate en échec est :
```text
cargo clippy --workspace --all-targets
```
Clippy relève onze violations localisées exclusivement dans `tests/yellowstone_publicnode_smoke.rs` : huit `clippy::expect_used`, deux `clippy::question_mark_used` et un `clippy::implicit_return`.
Aucun défaut fonctionnel du moteur Yellowstone, de Config ou du live PublicNode n'est révélé par ce gate.
## 3. Version technique
`workspace.package.version` devient :
```text
0.2.9-pre.13.fix.4
```
## 4. Correction du smoke
Le smoke conserve exactement le même contrat fonctionnel et opérateur que `fix.003` :
- deux lignes de token sur stdin, Mainnet puis Testnet ;
- metadata secrète `x-token` ;
- ouverture TLS puis `Subscribe` ;
- attente bornée d'un `YellowstoneSubscribeUpdate::Slot` ;
- `slot > 0` obligatoire ;
- fermeture gracieuse ou timeout KSP de half-close accepté uniquement après réception du slot ;
- aucune lecture Config/env KSP depuis Transport ;
- aucun secret dans URL, arguments ou diagnostics.
Seule la forme Rust du harness est corrigée :
- tous les `expect()` des helpers non annotés `#[test]` sont remplacés par des `match` explicites ;
- les deux propagations `?` sont remplacées par des branches `Result::Err` explicites ;
- la sortie du `async` d'attente de slot utilise `return update.slot()` ;
- la borne externe de fermeture est contrôlée par `match` plutôt que `expect()` ;
- aucun `#[allow(clippy::expect_used)]`, `#[allow(clippy::question_mark_used)]` ou `#[allow(clippy::implicit_return)]` n'est ajouté.
Le runtime Transport n'est pas modifié.
## 5. Inspection finale du graphe déjà exécutée
Le graphe Transport communiqué par l'opérateur confirme la stack gRPC attendue :
```text
yellowstone-grpc-proto 12.6.0
tonic 0.14.6
tonic-prost 0.14.6
prost 0.14.4
prost-types 0.14.4
```
Aucun `yellowstone-grpc-client` n'est introduit comme seconde abstraction runtime. Les doublons signalés par Cargo concernent notamment les contextes build/runtime et des transitifs génériques ; le graphe communiqué ne montre pas de seconde version concurrente de `tonic` ou `prost` dans la stack Yellowstone Transport.
## 6. Gate opérateur ciblé à rejouer
Le correctif ne changeant que le harness live et la version Cargo, le gate minimal est :
```bash
cargo fmt --all
python3 scripts/audit_rust_workspace_rules.py
python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.2.9
cargo check --workspace
cargo clippy --workspace --all-targets
cargo test -p ksp-onchain-transport-lib
cargo test --workspace
```
Puis le smoke live final, avec les credentials déjà validés :
```bash
read -rsp 'PublicNode Mainnet Yellowstone x-token: ' PUBLICNODE_MAINNET_TOKEN
echo
read -rsp 'PublicNode Testnet Yellowstone x-token: ' PUBLICNODE_TESTNET_TOKEN
echo
printf '%s\n%s\n' "$PUBLICNODE_MAINNET_TOKEN" "$PUBLICNODE_TESTNET_TOKEN" \
| cargo test -p ksp-onchain-transport-lib --test yellowstone_publicnode_smoke -- --ignored --nocapture
unset PUBLICNODE_MAINNET_TOKEN PUBLICNODE_TESTNET_TOKEN
```
Attendu :
```text
2 passed
0 failed
0 ignored
```
Les trois `cargo tree` n'ont pas besoin d'être rejoués si le payload appliqué correspond exactement à ce delta : aucune dépendance ni feature Cargo n'est modifiée.
## 7. Fichiers modifiés/ajoutés
```text
Cargo.toml
crates/ksp-onchain-transport-lib/tests/yellowstone_publicnode_smoke.rs
deltas/0.2.9/pre.013-fix.004.md
```