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

0.5.1-pre.002

Browse Source
This commit is contained in:
SinuS von SifriduS
2026-08-09 19:34:08 +02:00
parent 816eee59a9
commit 6a680767ae
767 changed files with 12257 additions and 12195 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
kb-app-demo-desktop/CHANGELOG.md
View File

@@ -1,8 +1,14 @@
<!-- file: kb-app-demo-desktop/CHANGELOG.md -->
<!-- version: 42 -->
<!-- version: 43 -->
# CHANGELOG — kb-app-demo-desktop
## `0.5.1-pre.002`
- adapte les dépendances Rust et tous les appels de crates Solana vers `ks_*` sans renommer l'application ;
- conserve `kb-app-demo-desktop` comme banc de validation et future surface de démonstrations propres au bot ;
- laisse les bindings TS-RS générés être régénérés par les tests après migration de `kb_config` vers `ks_config`.
## `0.5.1-pre.001`
### Documentation
@@ -14,7 +20,7 @@
### Documentation
- réaligne la frontière desktop/scénarios : les campagnes réutilisables appartiennent à `kb-pipeline-demo-scenarios`, tandis que le desktop conserve l’adaptation UI/Tauri, l’état applicatif et la présentation ;
- réaligne la frontière desktop/scénarios : les campagnes réutilisables appartiennent à `ks-pipeline-demo-scenarios`, tandis que le desktop conserve l’adaptation UI/Tauri, l’état applicatif et la présentation ;
- identifie pour `0.5.4` les dispatchs, critères de complétion et projections de preuves encore réutilisables à sortir du desktop ; aucun parcours runtime n’est modifié dans cette prerelease.
## 0.5.0-pre.001
@@ -39,11 +45,11 @@
- `pre.014-delta-fix-002` réaligne le test de contrôles Metaplex sur la nouvelle UI qualifiée (`metadataMetaplexCampaignSelect` + confirmation + exécution) et retire les assertions sur les anciens contrôles Devnet supprimés par `fix-001` ;
- après deux crashs reproductibles du desktop pendant `Create -> Mint — NFT`, les logs montrent `Create` simulé, soumis et confirmé, puis un arrêt brutal pendant le `getTransaction` de l'hydratation canonique, sans panic Rust ni erreur JSONL ;
- boxe explicitement le futur volumineux du dispatch des 11 campagnes Metaplex avant son exécution dans le runtime Tauri afin de réduire l'état async conservé par la commande desktop et ajoute des marqueurs backend `campaign_start`, `campaign_completed` et `campaign_failed` ; cette correction reste volontairement limitée à l'adaptateur desktop et ne modifie aucune campagne Devnet déjà qualifiée ;
- `pre.014-delta-fix-001` remplace le chemin Devnet Metaplex générique du panneau par 11 campagnes qualifiées réutilisant directement les runners spécialisés de `kb-pipeline-demo-scenarios` : cinq `Create -> Mint`, collection, Print/Burn, lifecycle pNFT, escrow, maintenance et probe Use ;
- `pre.014-delta-fix-001` remplace le chemin Devnet Metaplex générique du panneau par 11 campagnes qualifiées réutilisant directement les runners spécialisés de `ks-pipeline-demo-scenarios` : cinq `Create -> Mint`, collection, Print/Burn, lifecycle pNFT, escrow, maintenance et probe Use ;
- conserve les scénarios Metaplex synthétiques pour l’inspection de contrats, mais ne présente plus `scenario + step + intent JSON` comme parcours Devnet principal ;
- confine `Use`, `Resize`, `Migrate`, `Collect` et `CloseAccounts` aux probes simulation-only de leurs campagnes qualifiées et ne les expose jamais comme soumissions isolées ;
- déplace la carte **Exigences** en bas de la colonne droite, après les postconditions, tout en conservant le journal d’exécution en pleine largeur sous la grille ;
- enregistre la première validation Tauri de `pre.014` : `cargo check --workspace`, Clippy et l’audit workspace sont propres, `kb-pipeline-demo-scenarios` réussit 105 tests unitaires + 1 CLI + 1 API externe, et `kb-app-demo-desktop` réussit 139 tests unitaires ;
- enregistre la première validation Tauri de `pre.014` : `cargo check --workspace`, Clippy et l’audit workspace sont propres, `ks-pipeline-demo-scenarios` réussit 105 tests unitaires + 1 CLI + 1 API externe, et `kb-app-demo-desktop` réussit 139 tests unitaires ;
- les logs fournis confirment l’exécution desktop complète de Token-2022 Token Metadata et Solana Program Metadata sur Devnet, tandis que l’ancien parcours Metaplex s’arrêtait après la seule préparation de fixture, défaut de câblage corrigé par ce delta ;
- ajoute le troisième sous-panneau **Token-2022 Token Metadata** dans `demo_execution_metadata` ;
- appelle directement la campagne réutilisable de cinq opérations `Initialize -> UpdateField -> Emit -> RemoveKey -> UpdateAuthority` sur un mint Token-2022 frais ;
@@ -57,7 +63,7 @@
- `pre.013-delta-fix-022` restaure la compatibilité `Future + Send` de la commande Tauri Metaplex en corrigeant le runner partagé : l'effacement temporaire `Signer + Sync -> &dyn Signer` est limité à un helper synchrone de signature et n'est plus conservé au travers des `await` ; aucun assouplissement de la commande desktop n'est nécessaire ;
- `pre.013-delta-fix-002` retire la réécriture locale du JSON `Create` par famille et consomme désormais directement la fixture Metaplex réutilisable, afin d’éviter qu’un parcours `Fungible` annonce un token standard incompatible avec le mint réellement préparé ;
- conserve l’action Create autonome sur une fixture NFT par défaut, tandis que les parcours de scénario sélectionnent explicitement leur famille lors de la préparation.
- `pre.013-delta-fix-001` sérialise explicitement les summaries de backfill, extraction Core et replay dans l'evidence JSON au lieu d'exiger `serde::Serialize` sur les contrats internes de `kb-pipeline` ;
- `pre.013-delta-fix-001` sérialise explicitement les summaries de backfill, extraction Core et replay dans l'evidence JSON au lieu d'exiger `serde::Serialize` sur les contrats internes de `ks-pipeline` ;
- adapte l’appel Metaplex au runner Devnet renforcé sans ajouter encore de nouveau parcours UI ;
- initialise le store PostgreSQL avant une exécution Metaplex réelle et fournit le décodeur ainsi que les matérialiseurs runtime ;
- conserve dans l’evidence JSON le backfill canonique, l’extraction Core, le replay, la seconde passe d’idempotence, les matérialisations instructionnelles et le diagnostic post-exécution.
@@ -68,11 +74,11 @@
- renomme les contrats et commandes Tauri Metaplex afin de rendre leur domaine explicite ;
- remplace la réutilisation erronée de l’observer Solana Core par un observer Metadata ciblant exclusivement `demo_execution_metadata` ;
- déplace le garde de l’exécution Devnet partagée dans `demo_devnet_common` sous le nom générique `DemoExecutionRunGuard` ;
- consomme la borne RPC complète de `65536` octets exposée par `kb-onchain-transport` pour les lectures Solana Program Metadata ;
- consomme la borne RPC complète de `65536` octets exposée par `ks-onchain-transport` pour les lectures Solana Program Metadata ;
- ajoute un adaptateur desktop séparé pour les deux parcours Solana Program Metadata ;
- expose l’inventaire exact des neuf opérations et leurs états attendus ;
- synchronise le profil Devnet entre les sections Metaplex et Solana Program Metadata ;
- appelle directement la campagne réutilisable de `kb-pipeline-demo-scenarios` sans dupliquer la logique réseau ;
- appelle directement la campagne réutilisable de `ks-pipeline-demo-scenarios` sans dupliquer la logique réseau ;
- affiche la fixture, les deux signatures de préfinancement, les neuf simulations, confirmations, postconditions et snapshots matérialisés ;
- exige une confirmation explicite unique couvrant les deux préfinancements et les neuf mutations ;
- conserve les parcours Metaplex existants inchangés.
@@ -125,7 +131,7 @@
- remplace la préparation Metaplex fondée sur `solana-keygen`, `solana` et `spl-token` par une transaction Rust native ;
- crée le mint par `SystemCreateAccount` puis `SPL Token InitializeMint2` dans un même message simulé, signé et confirmé ;
- utilise explicitement le wallet du profil comme mint authority et freeze authority ;
- conserve le keypair du mint dans `kb-wallet` sans exposer ni déléguer ses secrets à une CLI externe.
- conserve le keypair du mint dans `ks-wallet` sans exposer ni déléguer ses secrets à une CLI externe.
## 0.4.7-pre.013-fix-009

22
kb-app-demo-desktop/Cargo.toml
View File

@@ -1,5 +1,5 @@
# file: kb-app-demo-desktop/Cargo.toml
# version: 6
# version: 7
[package]
name = "kb-app-demo-desktop"
@@ -23,16 +23,16 @@ tauri-build.workspace = true
[dependencies]
chrono.workspace = true
fs2.workspace = true
kb-config = { path = "../kb-config" }
kb-core = { path = "../kb-core" }
kb-logging = { path = "../kb-logging" }
kb-lib = { path = "../kb-lib" }
kb-program-ids = { path = "../kb-program-ids" }
kb-store = { path = "../kb-store" }
kb-wallet = { path = "../kb-wallet" }
kb-pipeline = { path = "../kb-pipeline" }
kb-pipeline-demo-scenarios = { path = "../kb-pipeline-demo-scenarios" }
kb-onchain-transport = { path = "../kb-onchain-transport" }
ks-config = { path = "../ks-config" }
ks-core = { path = "../ks-core" }
ks-logging = { path = "../ks-logging" }
ks-lib = { path = "../ks-lib" }
ks-program-ids = { path = "../ks-program-ids" }
ks-store = { path = "../ks-store" }
ks-wallet = { path = "../ks-wallet" }
ks-pipeline = { path = "../ks-pipeline" }
ks-pipeline-demo-scenarios = { path = "../ks-pipeline-demo-scenarios" }
ks-onchain-transport = { path = "../ks-onchain-transport" }
serde.workspace = true
serde_json.workspace = true
spl-associated-token-account-interface.workspace = true

12
kb-app-demo-desktop/README.md
View File

@@ -1,5 +1,5 @@
<!-- file: kb-app-demo-desktop/README.md -->
<!-- version: 13 -->
<!-- version: 14 -->
# kb-app-demo-desktop
@@ -17,21 +17,21 @@
## Frontière architecturale
Les commandes Tauri sont des adaptateurs minces. La logique réutilisable appartient à `kb-pipeline`, `kb-pipeline-demo-scenarios`, `kb-lib`, `kb-store` et `kb-onchain-transport`.
Les commandes Tauri sont des adaptateurs minces. La logique réutilisable appartient à `ks-pipeline`, `ks-pipeline-demo-scenarios`, `ks-lib`, `ks-store` et `ks-onchain-transport`.
Les campagnes Devnet/Testnet réutilisables appartiennent à `kb-pipeline-demo-scenarios`. Le desktop conserve leurs adaptateurs UI/Tauri, la sélection opérateur, la progression, les payloads TS-RS et la présentation ; `0.5.4` doit retirer les orchestrations réutilisables qui subsistent encore localement.
Les campagnes Devnet/Testnet réutilisables appartiennent à `ks-pipeline-demo-scenarios`. Le desktop conserve leurs adaptateurs UI/Tauri, la sélection opérateur, la progression, les payloads TS-RS et la présentation ; `0.5.4` doit retirer les orchestrations réutilisables qui subsistent encore localement.
## Exécution Metaplex Token Metadata
Le panneau conserve les scénarios synthétiques pour inspecter les contrats, mais son parcours Devnet principal expose désormais 11 campagnes qualifiées de `pre.013` et appelle directement leurs runners spécialisés de `kb-pipeline-demo-scenarios`. Les cinq variantes `Create -> Mint`, collection, Print/Burn, lifecycle pNFT et escrow soumettent uniquement les opérations autorisées ; Maintenance et Use conservent les opérations `unavailable` dans des probes simulation-only. Le desktop ne reconstruit pas les builders ; il conserve encore une partie du dispatch, des critères de complétion et de la projection de preuves, à centraliser en `0.5.4` lorsque cette logique est réutilisable.
Le panneau conserve les scénarios synthétiques pour inspecter les contrats, mais son parcours Devnet principal expose désormais 11 campagnes qualifiées de `pre.013` et appelle directement leurs runners spécialisés de `ks-pipeline-demo-scenarios`. Les cinq variantes `Create -> Mint`, collection, Print/Burn, lifecycle pNFT et escrow soumettent uniquement les opérations autorisées ; Maintenance et Use conservent les opérations `unavailable` dans des probes simulation-only. Le desktop ne reconstruit pas les builders ; il conserve encore une partie du dispatch, des critères de complétion et de la projection de preuves, à centraliser en `0.5.4` lorsque cette logique est réutilisable.
## Exécution Token-2022 Token Metadata
Le sous-panneau dédié appelle directement la campagne réutilisable de `kb-pipeline-demo-scenarios`; son parcours desktop complet a été confirmé sur Devnet pendant `pre.014`. Il crée un mint Token-2022 frais avec Metadata Pointer auto-référencé puis exécute, dans l’ordre, `Initialize`, `UpdateField`, `Emit`, `RemoveKey` et `UpdateAuthority`. Chaque étape passe par simulation, confirmation, replay canonique, matérialisation lorsque requise, lecture stateful et postcondition ; `Emit` conserve en plus sa return data validée.
Le sous-panneau dédié appelle directement la campagne réutilisable de `ks-pipeline-demo-scenarios`; son parcours desktop complet a été confirmé sur Devnet pendant `pre.014`. Il crée un mint Token-2022 frais avec Metadata Pointer auto-référencé puis exécute, dans l’ordre, `Initialize`, `UpdateField`, `Emit`, `RemoveKey` et `UpdateAuthority`. Chaque étape passe par simulation, confirmation, replay canonique, matérialisation lorsque requise, lecture stateful et postcondition ; `Emit` conserve en plus sa return data validée.
## Exécution Solana Program Metadata
Le même panneau expose séparément les deux parcours `Buffer` et `Metadata` de `ProgM6…`; sa campagne desktop complète a été confirmée sur Devnet pendant `pre.014`. La campagne complète crée deux PDA frais, confirme leurs préfinancements, exécute les neuf opérations stables, vérifie les lectures avant/après et affiche les snapshots matérialisés. La logique réseau reste entièrement dans `kb-pipeline-demo-scenarios` ; le desktop ne fait que sélectionner le profil, demander la confirmation et présenter les preuves.
Le même panneau expose séparément les deux parcours `Buffer` et `Metadata` de `ProgM6…`; sa campagne desktop complète a été confirmée sur Devnet pendant `pre.014`. La campagne complète crée deux PDA frais, confirme leurs préfinancements, exécute les neuf opérations stables, vérifie les lectures avant/après et affiche les snapshots matérialisés. La logique réseau reste entièrement dans `ks-pipeline-demo-scenarios` ; le desktop ne fait que sélectionner le profil, demander la confirmation et présenter les preuves.
## Documentation

4
kb-app-demo-desktop/TODO.md
View File

@@ -1,11 +1,11 @@
<!-- file: kb-app-demo-desktop/TODO.md -->
<!-- version: 15 -->
<!-- version: 16 -->
# TODO — kb-app-demo-desktop
## Évolutions générales
- [ ] `0.5.4` — réduire les panneaux d'exécution à l'adaptation UI/Tauri en déplaçant toute orchestration de campagne encore réutilisable vers `kb-pipeline-demo-scenarios`.
- [ ] `0.5.4` — réduire les panneaux d'exécution à l'adaptation UI/Tauri en déplaçant toute orchestration de campagne encore réutilisable vers `ks-pipeline-demo-scenarios`.
- [ ] UX — empêcher les doubles déclenchements pendant une préparation, simulation ou soumission active.
- [ ] Observabilité — afficher explicitement les comptes relus et les projections matérialisées.

6
kb-app-demo-desktop/USAGE.md
View File

@@ -1,5 +1,5 @@
<!-- file: kb-app-demo-desktop/USAGE.md -->
<!-- version: 14 -->
<!-- version: 15 -->
# Utilisation de kb-app-demo-desktop
@@ -32,7 +32,7 @@ Ne pas lancer `npm run build` directement. Tauri exécute le `beforeBuildCommand
La bibliothèque expose uniquement `run()` :
```rust
fn launch_desktop() -> kb_core::Result<()> {
fn launch_desktop() -> ks_core::Result<()> {
return kb_app_demo_desktop_lib::run();
}
```
@@ -170,7 +170,7 @@ Avant les scénarios Devnet, utiliser les fenêtres généralistes dans cet ordr
3. decode replay avec le Program ID `ProgM6…`, le décodeur `metadata.solana_program_metadata` et la matérialisation activée ;
4. lecture des événements du processor `materializer.metadata.solana_program_metadata`.
Ce parcours ne dépend pas de `kb-pipeline-demo-scenarios`. La fenêtre `demo_execution_metadata` et les scénarios Devnet `ProgM6…` seront ajoutés séparément dans `0.4.8-pre.009`.
Ce parcours ne dépend pas de `ks-pipeline-demo-scenarios`. La fenêtre `demo_execution_metadata` et les scénarios Devnet `ProgM6…` seront ajoutés séparément dans `0.4.8-pre.009`.
### Decode replay

4
kb-app-demo-desktop/frontend/demo_sql_replay_candidates.html
View File

@@ -1,5 +1,5 @@
<!-- file: kb-app-demo-desktop/frontend/demo_sql_replay_candidates.html -->
<!-- version: 10 -->
<!-- version: 11 -->
<!DOCTYPE html>
<html lang="fr">
@@ -194,7 +194,7 @@
<div class="card-body">
<div class="row g-3 align-items-end">
<div class="col-12 col-lg-5">
<label for="knownProgramSelect" class="form-label">Programme connu (kb_program_ids)</label>
<label for="knownProgramSelect" class="form-label">Programme connu (ks_program_ids)</label>
<select id="knownProgramSelect" class="form-select">
<option value="">Tous les programmes connus</option>
</select>

50
kb-app-demo-desktop/src/app_state.rs
View File

@@ -1,19 +1,19 @@
// file: kb-app-demo-desktop/src/app_state.rs
// version: 10
// version: 11
//! Shared Tauri application state and startup initialization.
/// Shared state managed by Tauri for the desktop demo application.
pub(crate) struct AppState {
config_path: std::string::String,
app_config: kb_config::AppConfig,
active_profile: kb_config::ProfileConfig,
logging_guard: std::sync::Mutex<kb_logging::LoggingGuard>,
http_pool: kb_onchain_transport::HttpEndpointPool,
app_config: ks_config::AppConfig,
active_profile: ks_config::ProfileConfig,
logging_guard: std::sync::Mutex<ks_logging::LoggingGuard>,
http_pool: ks_onchain_transport::HttpEndpointPool,
ws_pool:
std::sync::Mutex<std::option::Option<std::sync::Arc<kb_onchain_transport::WsEndpointPool>>>,
std::sync::Mutex<std::option::Option<std::sync::Arc<ks_onchain_transport::WsEndpointPool>>>,
demo_ws_session:
tokio::sync::Mutex<std::option::Option<std::sync::Arc<kb_onchain_transport::WsSession>>>,
tokio::sync::Mutex<std::option::Option<std::sync::Arc<ks_onchain_transport::WsSession>>>,
demo_backfill_running: std::sync::atomic::AtomicBool,
demo_backfill_cancel_requested: std::sync::atomic::AtomicBool,
demo_core_extraction_running: std::sync::atomic::AtomicBool,
@@ -28,26 +28,26 @@ pub(crate) struct AppState {
impl crate::AppState {
/// Initializes configuration, logging and shared runtime state.
pub(crate) fn initialize() -> kb_core::Result<crate::AppState> {
pub(crate) fn initialize() -> ks_core::Result<crate::AppState> {
let config_path = resolve_config_path();
let workspace_root = crate::workspace_root_dir();
let app_config = match kb_config::read_config_json_file_with_environment(
let app_config = match ks_config::read_config_json_file_with_environment(
&config_path,
&workspace_root,
) {
std::result::Result::Ok(config) => config,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
let active_profile = match kb_config::active_profile(&app_config) {
let active_profile = match ks_config::active_profile(&app_config) {
std::result::Result::Ok(profile) => profile.clone(),
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
let logging_config = convert_logging_config(&active_profile.logging);
let logging_guard = match kb_logging::init_logging(&logging_config) {
let logging_guard = match ks_logging::init_logging(&logging_config) {
std::result::Result::Ok(guard) => guard,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
let http_pool = match kb_onchain_transport::HttpEndpointPool::from_profile(&active_profile)
let http_pool = match ks_onchain_transport::HttpEndpointPool::from_profile(&active_profile)
{
std::result::Result::Ok(pool) => pool,
std::result::Result::Err(error) => return std::result::Result::Err(error),
@@ -79,29 +79,29 @@ impl crate::AppState {
}
/// Returns the complete parsed application configuration.
pub(crate) fn app_config(&self) -> &kb_config::AppConfig {
pub(crate) fn app_config(&self) -> &ks_config::AppConfig {
return &self.app_config;
}
/// Returns the active profile selected from the configuration.
pub(crate) fn active_profile(&self) -> &kb_config::ProfileConfig {
pub(crate) fn active_profile(&self) -> &ks_config::ProfileConfig {
return &self.active_profile;
}
/// Returns the configured HTTP endpoint pool.
pub(crate) fn http_pool(&self) -> &kb_onchain_transport::HttpEndpointPool {
pub(crate) fn http_pool(&self) -> &ks_onchain_transport::HttpEndpointPool {
return &self.http_pool;
}
/// Returns the lazily initialized WebSocket endpoint pool.
pub(crate) fn demo_ws_pool(
&self,
) -> kb_core::Result<std::sync::Arc<kb_onchain_transport::WsEndpointPool>> {
) -> ks_core::Result<std::sync::Arc<ks_onchain_transport::WsEndpointPool>> {
let lock_result = self.ws_pool.lock();
let mut guard = match lock_result {
std::result::Result::Ok(value) => value,
std::result::Result::Err(_) => {
return std::result::Result::Err(kb_core::Error::invalid_state(
return std::result::Result::Err(ks_core::Error::invalid_state(
"demo WebSocket pool lock is poisoned",
));
},
@@ -109,7 +109,7 @@ impl crate::AppState {
if let std::option::Option::Some(pool) = guard.as_ref() {
return std::result::Result::Ok(std::sync::Arc::clone(pool));
}
let pool = match kb_onchain_transport::WsEndpointPool::from_profile(&self.active_profile) {
let pool = match ks_onchain_transport::WsEndpointPool::from_profile(&self.active_profile) {
std::result::Result::Ok(value) => std::sync::Arc::new(value),
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
@@ -120,7 +120,7 @@ impl crate::AppState {
/// Returns the persistent WebSocket demo session slot.
pub(crate) fn demo_ws_session(
&self,
) -> &tokio::sync::Mutex<std::option::Option<std::sync::Arc<kb_onchain_transport::WsSession>>>
) -> &tokio::sync::Mutex<std::option::Option<std::sync::Arc<ks_onchain_transport::WsSession>>>
{
return &self.demo_ws_session;
}
@@ -198,10 +198,10 @@ impl crate::AppState {
}
}
fn convert_logging_config(config: &kb_config::LoggingConfig) -> kb_logging::LoggingConfig {
let mut targets = std::vec::Vec::<kb_logging::LogTargetConfig>::new();
fn convert_logging_config(config: &ks_config::LoggingConfig) -> ks_logging::LoggingConfig {
let mut targets = std::vec::Vec::<ks_logging::LogTargetConfig>::new();
for target in &config.targets {
targets.push(kb_logging::LogTargetConfig {
targets.push(ks_logging::LogTargetConfig {
name: target.name.clone(),
enabled: target.enabled,
sink: target.sink.clone(),
@@ -213,14 +213,14 @@ fn convert_logging_config(config: &kb_config::LoggingConfig) -> kb_logging::Logg
targets: target.targets.clone(),
});
}
let mut target_filters = std::vec::Vec::<kb_logging::LogTargetFilterConfig>::new();
let mut target_filters = std::vec::Vec::<ks_logging::LogTargetFilterConfig>::new();
for filter in &config.target_filters {
target_filters.push(kb_logging::LogTargetFilterConfig {
target_filters.push(ks_logging::LogTargetFilterConfig {
target: filter.target.clone(),
level: filter.level.clone(),
});
}
return kb_logging::LoggingConfig {
return ks_logging::LoggingConfig {
default_level: config.default_level.clone(),
targets,
target_filters,

52
kb-app-demo-desktop/src/demo_backfill.rs
View File

@@ -1,5 +1,5 @@
// file: kb-app-demo-desktop/src/demo_backfill.rs
// version: 15
// version: 16
//! Tauri commands and UI payloads for bounded HTTP transaction backfills.
@@ -193,8 +193,8 @@ pub(crate) struct DemoBackfillObserver<'a> {
pub(crate) cancel_requested: &'a std::sync::atomic::AtomicBool,
}
impl kb_pipeline::BackfillObserver for crate::DemoBackfillObserver<'_> {
fn on_progress(&self, event: &kb_pipeline::BackfillProgressEvent) {
impl ks_pipeline::BackfillObserver for crate::DemoBackfillObserver<'_> {
fn on_progress(&self, event: &ks_pipeline::BackfillProgressEvent) {
let payload = crate::DemoBackfillProgressPayload {
timestamp: event.timestamp.clone(),
level: event.level.code().to_string(),
@@ -244,7 +244,7 @@ pub(crate) fn demo_backfill_options(
} else {
roles.first().map(|item| return item.role.clone())
};
let programs = kb_program_ids::registered_program_ids()
let programs = ks_program_ids::registered_program_ids()
.iter()
.map(|entry| {
return crate::DemoBackfillProgramOption {
@@ -289,7 +289,7 @@ pub(crate) async fn demo_backfill_execute(
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
let profile = state.active_profile();
let store_options = match kb_store::PostgresStoreOptions::new(
let store_options = match ks_store::PostgresStoreOptions::new(
profile.database.postgres.url.clone(),
profile.database.postgres.max_connections,
profile.database.postgres.connect_timeout_ms,
@@ -298,7 +298,7 @@ pub(crate) async fn demo_backfill_execute(
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
};
let store = match kb_store::PostgresStore::connect(store_options).await {
let store = match ks_store::PostgresStore::connect(store_options).await {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
};
@@ -309,7 +309,7 @@ pub(crate) async fn demo_backfill_execute(
app_handle,
cancel_requested: state.demo_backfill_cancel_requested(),
};
let summary = match kb_pipeline::execute_http_backfill(
let summary = match ks_pipeline::execute_http_backfill(
state.http_pool(),
&store,
&pipeline_request,
@@ -324,7 +324,7 @@ pub(crate) async fn demo_backfill_execute(
}
fn build_role_options(
snapshots: std::vec::Vec<kb_onchain_transport::HttpPoolClientSnapshot>,
snapshots: std::vec::Vec<ks_onchain_transport::HttpPoolClientSnapshot>,
) -> std::vec::Vec<crate::DemoBackfillRoleOption> {
let mut role_methods = std::collections::BTreeMap::<
std::string::String,
@@ -364,25 +364,25 @@ fn build_role_options(
fn build_pipeline_request(
request: DemoBackfillRequest,
) -> std::result::Result<kb_pipeline::BackfillRequest, std::string::String> {
) -> std::result::Result<ks_pipeline::BackfillRequest, std::string::String> {
let source_result = match request.mode.trim() {
"explicit_signatures" => explicit_source(request.signatures_text.as_deref()),
"program" => address_source(
kb_pipeline::BackfillAddressKind::Program,
ks_pipeline::BackfillAddressKind::Program,
request.address.as_deref(),
request.anchor_signature.as_deref(),
request.direction.as_deref(),
request.limit,
),
"token" => address_source(
kb_pipeline::BackfillAddressKind::Token,
ks_pipeline::BackfillAddressKind::Token,
request.address.as_deref(),
request.anchor_signature.as_deref(),
request.direction.as_deref(),
request.limit,
),
"pool" => address_source(
kb_pipeline::BackfillAddressKind::Pool,
ks_pipeline::BackfillAddressKind::Pool,
request.address.as_deref(),
request.anchor_signature.as_deref(),
request.direction.as_deref(),
@@ -394,7 +394,7 @@ fn build_pipeline_request(
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
let pipeline_request = kb_pipeline::BackfillRequest {
let pipeline_request = ks_pipeline::BackfillRequest {
role: request.role,
commitment: request.commitment,
source,
@@ -412,7 +412,7 @@ fn build_pipeline_request(
fn explicit_source(
signatures_text: std::option::Option<&str>,
) -> std::result::Result<kb_pipeline::BackfillSource, std::string::String> {
) -> std::result::Result<ks_pipeline::BackfillSource, std::string::String> {
let text = match signatures_text {
std::option::Option::Some(value) => value,
std::option::Option::None => "",
@@ -428,16 +428,16 @@ fn explicit_source(
"the signatures textarea must contain at least one signature".to_string(),
);
}
return std::result::Result::Ok(kb_pipeline::BackfillSource::ExplicitSignatures(signatures));
return std::result::Result::Ok(ks_pipeline::BackfillSource::ExplicitSignatures(signatures));
}
fn address_source(
kind: kb_pipeline::BackfillAddressKind,
kind: ks_pipeline::BackfillAddressKind,
address: std::option::Option<&str>,
anchor_signature: std::option::Option<&str>,
direction: std::option::Option<&str>,
limit: u32,
) -> std::result::Result<kb_pipeline::BackfillSource, std::string::String> {
) -> std::result::Result<ks_pipeline::BackfillSource, std::string::String> {
let address_text = match address {
std::option::Option::Some(value) => value,
std::option::Option::None => "",
@@ -451,8 +451,8 @@ fn address_source(
std::option::Option::None => "",
};
let direction_value = match direction_text.trim() {
"before" => kb_pipeline::BackfillDirection::Before,
"after" => kb_pipeline::BackfillDirection::After,
"before" => ks_pipeline::BackfillDirection::Before,
"after" => ks_pipeline::BackfillDirection::After,
_ => {
return std::result::Result::Err("direction must be before or after".to_string());
},
@@ -461,7 +461,7 @@ fn address_source(
.map(str::trim)
.filter(|value| return !value.is_empty())
.map(str::to_string);
if direction_value == kb_pipeline::BackfillDirection::After && anchor_value.is_none() {
if direction_value == ks_pipeline::BackfillDirection::After && anchor_value.is_none() {
return std::result::Result::Err(
"anchor signature is required for newer-history backfill".to_string(),
);
@@ -472,7 +472,7 @@ fn address_source(
return std::result::Result::Err(format!("signature limit conversion failed: {error}"));
},
};
return std::result::Result::Ok(kb_pipeline::BackfillSource::AddressHistory {
return std::result::Result::Ok(ks_pipeline::BackfillSource::AddressHistory {
kind,
address: address_value.to_string(),
anchor_signature: anchor_value,
@@ -481,7 +481,7 @@ fn address_source(
});
}
fn summary_payload(summary: kb_pipeline::BackfillSummary) -> DemoBackfillSummaryPayload {
fn summary_payload(summary: ks_pipeline::BackfillSummary) -> DemoBackfillSummaryPayload {
return crate::DemoBackfillSummaryPayload {
capture_session_id: summary.capture_session_id,
filter_code: summary.filter_code,
@@ -520,7 +520,7 @@ mod tests {
};
assert_eq!(
source,
kb_pipeline::BackfillSource::ExplicitSignatures(std::vec![
ks_pipeline::BackfillSource::ExplicitSignatures(std::vec![
"first".to_string(),
"second".to_string(),
])
@@ -530,7 +530,7 @@ mod tests {
#[test]
fn older_history_accepts_missing_anchor_and_uses_latest_filter() {
let source_result = super::address_source(
kb_pipeline::BackfillAddressKind::Program,
ks_pipeline::BackfillAddressKind::Program,
std::option::Option::Some("11111111111111111111111111111111"),
std::option::Option::Some(" "),
std::option::Option::Some("before"),
@@ -540,7 +540,7 @@ mod tests {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => panic!("source failed: {error}"),
};
let request = kb_pipeline::BackfillRequest {
let request = ks_pipeline::BackfillRequest {
role: "history_backfill".to_string(),
commitment: "confirmed".to_string(),
source,
@@ -556,7 +556,7 @@ mod tests {
#[test]
fn newer_history_rejects_missing_anchor() {
let source_result = super::address_source(
kb_pipeline::BackfillAddressKind::Program,
ks_pipeline::BackfillAddressKind::Program,
std::option::Option::Some("11111111111111111111111111111111"),
std::option::Option::None,
std::option::Option::Some("after"),

8
kb-app-demo-desktop/src/demo_config.rs
View File

@@ -1,5 +1,5 @@
// file: kb-app-demo-desktop/src/demo_config.rs
// version: 2
// version: 3
//! Configuration demo payload and state projection.
@@ -19,9 +19,9 @@ pub(crate) struct DemoConfigPayload {
/// Active profile environment.
pub(crate) environment: std::string::String,
/// Entire parsed configuration.
pub(crate) app_config: kb_config::AppConfig,
pub(crate) app_config: ks_config::AppConfig,
/// Active profile configuration.
pub(crate) active_profile: kb_config::ProfileConfig,
pub(crate) active_profile: ks_config::ProfileConfig,
/// Embedded JSON Schema text used during loading.
pub(crate) schema_json: std::string::String,
}
@@ -34,7 +34,7 @@ pub(crate) fn demo_config_payload(state: &crate::AppState) -> crate::DemoConfigP
environment: state.active_profile().app.environment.clone(),
app_config: state.app_config().clone(),
active_profile: state.active_profile().clone(),
schema_json: kb_config::config_json_schema_text().to_owned(),
schema_json: ks_config::config_json_schema_text().to_owned(),
};
}

26
kb-app-demo-desktop/src/demo_core_extraction.rs
View File

@@ -1,5 +1,5 @@
// file: kb-app-demo-desktop/src/demo_core_extraction.rs
// version: 13
// version: 14
//! Tauri commands and UI payloads for canonical transaction to core extraction.
@@ -137,8 +137,8 @@ pub(crate) struct DemoCoreExtractionObserver<'a> {
pub(crate) cancel_requested: &'a std::sync::atomic::AtomicBool,
}
impl kb_pipeline::CoreExtractionObserver for crate::DemoCoreExtractionObserver<'_> {
fn on_progress(&self, event: &kb_pipeline::CoreExtractionProgressEvent) {
impl ks_pipeline::CoreExtractionObserver for crate::DemoCoreExtractionObserver<'_> {
fn on_progress(&self, event: &ks_pipeline::CoreExtractionProgressEvent) {
let payload = crate::DemoCoreExtractionProgressPayload {
timestamp: event.timestamp.clone(),
level: event.level.code().to_string(),
@@ -178,11 +178,11 @@ pub(crate) fn demo_core_extraction_options_payload(
state: &crate::AppState,
) -> crate::DemoCoreExtractionOptionsPayload {
return crate::DemoCoreExtractionOptionsPayload {
processor_version: kb_pipeline::CORE_EXTRACTION_PROCESSOR_VERSION.to_string(),
processor_version: ks_pipeline::CORE_EXTRACTION_PROCESSOR_VERSION.to_string(),
default_limit: 100,
default_max_concurrent_extractions: 4,
running: state.demo_core_extraction_running().load(std::sync::atomic::Ordering::Acquire),
programs: kb_program_ids::registered_program_ids()
programs: ks_program_ids::registered_program_ids()
.iter()
.map(|entry| {
return crate::DemoCoreExtractionProgramOption {
@@ -231,7 +231,7 @@ pub(crate) async fn demo_core_extraction_execute(
cancel_requested: state.demo_core_extraction_cancel_requested(),
};
let summary_result =
kb_pipeline::execute_core_extraction(&store, &pipeline_request, &observer).await;
ks_pipeline::execute_core_extraction(&store, &pipeline_request, &observer).await;
let summary = match summary_result {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
@@ -249,13 +249,13 @@ pub(crate) fn demo_core_extraction_cancel(state: &crate::AppState) -> bool {
fn build_pipeline_request(
request: crate::DemoCoreExtractionRequest,
) -> std::result::Result<kb_pipeline::CoreExtractionRequest, std::string::String> {
) -> std::result::Result<ks_pipeline::CoreExtractionRequest, std::string::String> {
let source_result = match request.mode.trim() {
"signatures" => {
let signatures = split_signatures(request.signatures_text.as_deref());
std::result::Result::Ok(kb_pipeline::CoreExtractionSource::Signatures(signatures))
std::result::Result::Ok(ks_pipeline::CoreExtractionSource::Signatures(signatures))
},
"pending" => std::result::Result::Ok(kb_pipeline::CoreExtractionSource::Pending),
"pending" => std::result::Result::Ok(ks_pipeline::CoreExtractionSource::Pending),
"program_id" => {
let program_id = match request.program_id {
std::option::Option::Some(value) if !value.trim().is_empty() => value,
@@ -265,7 +265,7 @@ fn build_pipeline_request(
);
},
};
std::result::Result::Ok(kb_pipeline::CoreExtractionSource::ProgramId { program_id })
std::result::Result::Ok(ks_pipeline::CoreExtractionSource::ProgramId { program_id })
},
"slot_range" => {
let min_slot = match request.min_slot {
@@ -284,7 +284,7 @@ fn build_pipeline_request(
);
},
};
std::result::Result::Ok(kb_pipeline::CoreExtractionSource::SlotRange {
std::result::Result::Ok(ks_pipeline::CoreExtractionSource::SlotRange {
min_slot,
max_slot,
})
@@ -295,7 +295,7 @@ fn build_pipeline_request(
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
let pipeline_request = kb_pipeline::CoreExtractionRequest {
let pipeline_request = ks_pipeline::CoreExtractionRequest {
source,
limit: request.limit,
max_concurrent_extractions: request.max_concurrent_extractions,
@@ -309,7 +309,7 @@ fn build_pipeline_request(
}
fn summary_payload(
summary: kb_pipeline::CoreExtractionSummary,
summary: ks_pipeline::CoreExtractionSummary,
) -> crate::DemoCoreExtractionSummaryPayload {
return crate::DemoCoreExtractionSummaryPayload {
processor_version: summary.processor_version,

182
kb-app-demo-desktop/src/demo_decode_replay.rs
View File

@@ -1,5 +1,5 @@
// file: kb-app-demo-desktop/src/demo_decode_replay.rs
// version: 39
// version: 40
//! Tauri commands and UI payloads for contextual instruction decode replay.
@@ -319,8 +319,8 @@ pub(crate) struct DemoDecodeReplayObserver<'a> {
pub(crate) cancel_requested: &'a std::sync::atomic::AtomicBool,
}
impl kb_pipeline::DecodeReplayObserver for crate::DemoDecodeReplayObserver<'_> {
fn on_progress(&self, event: &kb_pipeline::DecodeReplayProgressEvent) {
impl ks_pipeline::DecodeReplayObserver for crate::DemoDecodeReplayObserver<'_> {
fn on_progress(&self, event: &ks_pipeline::DecodeReplayProgressEvent) {
let payload = crate::DemoDecodeReplayProgressPayload {
campaign_id: self.campaign_id.clone(),
timestamp: event.timestamp.clone(),
@@ -385,7 +385,7 @@ pub(crate) fn demo_decode_replay_options(
return format!("{}@{}", identity.name, identity.version);
})
.collect::<std::vec::Vec<_>>();
let programs = kb_program_ids::registered_program_ids()
let programs = ks_program_ids::registered_program_ids()
.iter()
.map(|entry| {
return crate::DemoDecodeReplayProgramOption {
@@ -398,7 +398,7 @@ pub(crate) fn demo_decode_replay_options(
tracing::debug!(
target: crate::TRACING_TARGET,
action = "load_options",
pipeline_version = kb_pipeline::DECODE_PIPELINE_VERSION,
pipeline_version = ks_pipeline::DECODE_PIPELINE_VERSION,
decoder_count = decoder_options.len(),
materializer_names = ?materializer_names,
default_limit = 100_u32,
@@ -407,7 +407,7 @@ pub(crate) fn demo_decode_replay_options(
"return contextual decode replay options"
);
return crate::DemoDecodeReplayOptionsPayload {
pipeline_version: kb_pipeline::DECODE_PIPELINE_VERSION.to_string(),
pipeline_version: ks_pipeline::DECODE_PIPELINE_VERSION.to_string(),
decoders: decoder_options,
materializer_names,
programs,
@@ -423,7 +423,7 @@ pub(crate) async fn demo_decode_replay_execute(
state: tauri::State<'_, crate::AppState>,
request: crate::DemoDecodeReplayRequest,
) -> std::result::Result<crate::DemoDecodeReplaySummaryPayload, std::string::String> {
let campaign_id = kb_pipeline::new_decode_campaign_id();
let campaign_id = ks_pipeline::new_decode_campaign_id();
tracing::debug!(
target: crate::TRACING_TARGET,
action = "execute",
@@ -510,7 +510,7 @@ pub(crate) async fn demo_decode_replay_execute(
campaign_id: pipeline_request.campaign_id.clone(),
cancel_requested: state.demo_decode_replay_cancel_requested(),
};
let summary_result = kb_pipeline::execute_decode_replay(
let summary_result = ks_pipeline::execute_decode_replay(
&store,
&pipeline_request,
decoders.as_slice(),
@@ -582,7 +582,7 @@ pub(crate) async fn demo_decode_replay_diagnostics(
})
.map(crate::table_snapshot_from_pg)
.collect();
let coverage_result = kb_store::DecodePipelineStore::list_decode_coverage_summary(
let coverage_result = ks_store::DecodePipelineStore::list_decode_coverage_summary(
&store,
std::option::Option::None,
std::option::Option::None,
@@ -605,7 +605,7 @@ pub(crate) async fn demo_decode_replay_annotations(
state: tauri::State<'_, crate::AppState>,
request: crate::DemoTransactionAnnotationRequest,
) -> std::result::Result<std::vec::Vec<crate::DemoTransactionAnnotationRow>, std::string::String> {
let filter_result = kb_store::MaterializedEventFilter::new(
let filter_result = ks_store::MaterializedEventFilter::new(
std::option::Option::Some("materializer.transaction.annotations".to_string()),
std::option::Option::Some("transaction_annotation".to_string()),
request.signature_contains,
@@ -622,7 +622,7 @@ pub(crate) async fn demo_decode_replay_annotations(
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
let rows_result =
kb_store::DecodePipelineStore::list_materialized_events(&store, &filter).await;
ks_store::DecodePipelineStore::list_materialized_events(&store, &filter).await;
let rows = match rows_result {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
@@ -656,39 +656,39 @@ fn register_active_campaign(
return std::result::Result::Ok(());
}
fn available_materializers() -> std::vec::Vec<std::sync::Arc<dyn kb_lib::MtApiEventMaterializer>> {
fn available_materializers() -> std::vec::Vec<std::sync::Arc<dyn ks_lib::MtApiEventMaterializer>> {
return std::vec![
std::sync::Arc::new(kb_lib::MtAdminMaterializer),
std::sync::Arc::new(kb_lib::MtComplianceAuditMaterializer),
std::sync::Arc::new(kb_lib::MtFeesMaterializer),
std::sync::Arc::new(kb_lib::MtLifecycleMaterializer),
std::sync::Arc::new(kb_lib::MtMetadataMetaplexTokenMetadataMaterializer),
std::sync::Arc::new(kb_lib::MtMetadataSolanaProgramMaterializer),
std::sync::Arc::new(kb_lib::MtMetadataToken2022Materializer),
std::sync::Arc::new(kb_lib::MtStakingMaterializer),
std::sync::Arc::new(kb_lib::MtTokenAccountsMaterializer),
std::sync::Arc::new(kb_lib::MtRiskMaterializer),
std::sync::Arc::new(kb_lib::MtTransactionAnnotationMaterializer),
std::sync::Arc::new(ks_lib::MtAdminMaterializer),
std::sync::Arc::new(ks_lib::MtComplianceAuditMaterializer),
std::sync::Arc::new(ks_lib::MtFeesMaterializer),
std::sync::Arc::new(ks_lib::MtLifecycleMaterializer),
std::sync::Arc::new(ks_lib::MtMetadataMetaplexTokenMetadataMaterializer),
std::sync::Arc::new(ks_lib::MtMetadataSolanaProgramMaterializer),
std::sync::Arc::new(ks_lib::MtMetadataToken2022Materializer),
std::sync::Arc::new(ks_lib::MtStakingMaterializer),
std::sync::Arc::new(ks_lib::MtTokenAccountsMaterializer),
std::sync::Arc::new(ks_lib::MtRiskMaterializer),
std::sync::Arc::new(ks_lib::MtTransactionAnnotationMaterializer),
];
}
fn available_decoders() -> std::vec::Vec<std::sync::Arc<dyn kb_lib::DcApiInstructionDecoder>> {
fn available_decoders() -> std::vec::Vec<std::sync::Arc<dyn ks_lib::DcApiInstructionDecoder>> {
return std::vec![
std::sync::Arc::new(kb_lib::DcSolanaCoreDecoder),
std::sync::Arc::new(kb_lib::DcMetadataMetaplexTokenMetadataDecoder),
std::sync::Arc::new(kb_lib::DcMetadataSolanaProgramMetadataDecoder),
std::sync::Arc::new(kb_lib::DcSplAssociatedTokenAccountDecoder),
std::sync::Arc::new(kb_lib::DcSplElgamalRegistryDecoder),
std::sync::Arc::new(kb_lib::DcSplMemoDecoder),
std::sync::Arc::new(kb_lib::DcSplTokenDecoder),
std::sync::Arc::new(kb_lib::DcSplToken2022Decoder),
std::sync::Arc::new(ks_lib::DcSolanaCoreDecoder),
std::sync::Arc::new(ks_lib::DcMetadataMetaplexTokenMetadataDecoder),
std::sync::Arc::new(ks_lib::DcMetadataSolanaProgramMetadataDecoder),
std::sync::Arc::new(ks_lib::DcSplAssociatedTokenAccountDecoder),
std::sync::Arc::new(ks_lib::DcSplElgamalRegistryDecoder),
std::sync::Arc::new(ks_lib::DcSplMemoDecoder),
std::sync::Arc::new(ks_lib::DcSplTokenDecoder),
std::sync::Arc::new(ks_lib::DcSplToken2022Decoder),
];
}
fn build_pipeline_request(
request: crate::DemoDecodeReplayRequest,
campaign_id: std::string::String,
) -> std::result::Result<kb_pipeline::DecodeReplayRequest, std::string::String> {
) -> std::result::Result<ks_pipeline::DecodeReplayRequest, std::string::String> {
let states_result = processing_states(request.instruction_state.as_str());
let states = match states_result {
std::result::Result::Ok(value) => value,
@@ -703,7 +703,7 @@ fn build_pipeline_request(
},
_ => std::vec::Vec::new(),
};
let selection_result = kb_store::DecodeSelectionFilter::new(
let selection_result = ks_store::DecodeSelectionFilter::new(
signatures,
states,
std::option::Option::None,
@@ -718,11 +718,11 @@ fn build_pipeline_request(
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
};
let dispatch_policy = if request.all_compatible {
kb_pipeline::DecodeDispatchPolicy::AllCompatible
ks_pipeline::DecodeDispatchPolicy::AllCompatible
} else {
kb_pipeline::DecodeDispatchPolicy::HighestPriority
ks_pipeline::DecodeDispatchPolicy::HighestPriority
};
let pipeline_request = kb_pipeline::DecodeReplayRequest {
let pipeline_request = ks_pipeline::DecodeReplayRequest {
campaign_id,
selection,
decoder_names: request.decoder_names,
@@ -773,31 +773,31 @@ fn text_sample(values: &[std::string::String], limit: usize) -> std::vec::Vec<&s
fn processing_states(
value: &str,
) -> std::result::Result<std::vec::Vec<kb_store::CoreInstructionProcessingState>, std::string::String>
) -> std::result::Result<std::vec::Vec<ks_store::CoreInstructionProcessingState>, std::string::String>
{
return match value.trim() {
"incomplete_signatures" | "actionable" => std::result::Result::Ok(std::vec![
kb_store::CoreInstructionProcessingState::Pending,
kb_store::CoreInstructionProcessingState::Failed,
kb_store::CoreInstructionProcessingState::ReplayRequested,
ks_store::CoreInstructionProcessingState::Pending,
ks_store::CoreInstructionProcessingState::Failed,
ks_store::CoreInstructionProcessingState::ReplayRequested,
]),
"pending" => {
std::result::Result::Ok(std::vec![kb_store::CoreInstructionProcessingState::Pending])
std::result::Result::Ok(std::vec![ks_store::CoreInstructionProcessingState::Pending])
},
"failed" => {
std::result::Result::Ok(std::vec![kb_store::CoreInstructionProcessingState::Failed])
std::result::Result::Ok(std::vec![ks_store::CoreInstructionProcessingState::Failed])
},
"replay_requested" => std::result::Result::Ok(std::vec![
kb_store::CoreInstructionProcessingState::ReplayRequested
ks_store::CoreInstructionProcessingState::ReplayRequested
]),
"decoded" => {
std::result::Result::Ok(std::vec![kb_store::CoreInstructionProcessingState::Decoded])
std::result::Result::Ok(std::vec![ks_store::CoreInstructionProcessingState::Decoded])
},
"ignored" => {
std::result::Result::Ok(std::vec![kb_store::CoreInstructionProcessingState::Ignored])
std::result::Result::Ok(std::vec![ks_store::CoreInstructionProcessingState::Ignored])
},
"materialized" => std::result::Result::Ok(std::vec![
kb_store::CoreInstructionProcessingState::Materialized
ks_store::CoreInstructionProcessingState::Materialized
]),
_ => std::result::Result::Err("unsupported instruction processing state".to_string()),
};
@@ -823,7 +823,7 @@ fn split_lines(text: std::option::Option<&str>) -> std::vec::Vec<std::string::St
}
fn summary_payload(
summary: kb_pipeline::DecodeReplaySummary,
summary: ks_pipeline::DecodeReplaySummary,
) -> crate::DemoDecodeReplaySummaryPayload {
return crate::DemoDecodeReplaySummaryPayload {
campaign_id: summary.campaign_id,
@@ -861,7 +861,7 @@ fn summary_payload(
}
fn coverage_payload(
value: kb_store::DecodeCoverageSummaryRow,
value: ks_store::DecodeCoverageSummaryRow,
) -> crate::DemoDecodeCoverageSummaryPayload {
return crate::DemoDecodeCoverageSummaryPayload {
processor_name: value.processor_name,
@@ -882,7 +882,7 @@ fn coverage_payload(
}
fn annotation_payload(
row: kb_store::MaterializedEventQueryRow,
row: ks_store::MaterializedEventQueryRow,
) -> std::result::Result<crate::DemoTransactionAnnotationRow, std::string::String> {
if row.processor_name != "materializer.transaction.annotations"
|| row.materialized_family != "transaction_annotation"
@@ -994,31 +994,31 @@ fn required_annotation_text(
#[cfg(test)]
mod tests {
fn ata_observation(entry: &str) -> kb_lib::DcApiDecodedObservation {
return kb_lib::DcApiDecodedObservation {
fn ata_observation(entry: &str) -> ks_lib::DcApiDecodedObservation {
return ks_lib::DcApiDecodedObservation {
event_key: format!("ata:{entry}:0"),
event: kb_lib::MdDecodedProtocolEvent {
signature: kb_lib::MdSignature("signature".to_string()),
slot: kb_lib::MdSlot(1),
instruction_path: kb_lib::MdInstructionPath("0".to_string()),
program_id: kb_lib::MdProgramId(
kb_program_ids::ASSOCIATED_TOKEN_PROGRAM_ID.to_string(),
event: ks_lib::MdDecodedProtocolEvent {
signature: ks_lib::MdSignature("signature".to_string()),
slot: ks_lib::MdSlot(1),
instruction_path: ks_lib::MdInstructionPath("0".to_string()),
program_id: ks_lib::MdProgramId(
ks_program_ids::ASSOCIATED_TOKEN_PROGRAM_ID.to_string(),
),
protocol_code: kb_lib::MdProtocolCode("spl.associated_token_account".to_string()),
surface_code: kb_lib::MdSurfaceCode("spl.associated_token_account".to_string()),
event_code: kb_lib::MdEventCode(format!("spl.associated_token_account.{entry}")),
event_name: kb_lib::MdEventName(entry.to_string()),
event_family: kb_lib::MdEventFamily::Lifecycle,
source_kind: kb_lib::MdEventSourceKind::Instruction,
confidence: kb_lib::MdDecoderConfidence::ManualExact,
protocol_code: ks_lib::MdProtocolCode("spl.associated_token_account".to_string()),
surface_code: ks_lib::MdSurfaceCode("spl.associated_token_account".to_string()),
event_code: ks_lib::MdEventCode(format!("spl.associated_token_account.{entry}")),
event_name: ks_lib::MdEventName(entry.to_string()),
event_family: ks_lib::MdEventFamily::Lifecycle,
source_kind: ks_lib::MdEventSourceKind::Instruction,
confidence: ks_lib::MdDecoderConfidence::ManualExact,
},
payload_json: serde_json::json!({}),
transaction_failed: false,
transaction_error: std::option::Option::None,
observation_committed: true,
proof: kb_lib::DcApiDecoderProof {
kind: kb_lib::DcApiDecoderProofKind::Manual,
confidence: kb_lib::MdDecoderConfidence::ManualExact,
proof: ks_lib::DcApiDecoderProof {
kind: ks_lib::DcApiDecoderProofKind::Manual,
confidence: ks_lib::MdDecoderConfidence::ManualExact,
evidence: std::vec!["fixture".to_string()],
},
};
@@ -1028,21 +1028,21 @@ mod tests {
program_id: &str,
surface: &str,
entry: &str,
) -> kb_lib::DcApiDecodedObservation {
return kb_lib::DcApiDecodedObservation {
) -> ks_lib::DcApiDecodedObservation {
return ks_lib::DcApiDecodedObservation {
event_key: format!("{surface}:{entry}:0"),
event: kb_lib::MdDecodedProtocolEvent {
signature: kb_lib::MdSignature("signature".to_string()),
slot: kb_lib::MdSlot(1),
instruction_path: kb_lib::MdInstructionPath("0".to_string()),
program_id: kb_lib::MdProgramId(program_id.to_string()),
protocol_code: kb_lib::MdProtocolCode(surface.to_string()),
surface_code: kb_lib::MdSurfaceCode(surface.to_string()),
event_code: kb_lib::MdEventCode(format!("{surface}.{entry}")),
event_name: kb_lib::MdEventName(entry.to_string()),
event_family: kb_lib::MdEventFamily::Metadata,
source_kind: kb_lib::MdEventSourceKind::Instruction,
confidence: kb_lib::MdDecoderConfidence::ManualExact,
event: ks_lib::MdDecodedProtocolEvent {
signature: ks_lib::MdSignature("signature".to_string()),
slot: ks_lib::MdSlot(1),
instruction_path: ks_lib::MdInstructionPath("0".to_string()),
program_id: ks_lib::MdProgramId(program_id.to_string()),
protocol_code: ks_lib::MdProtocolCode(surface.to_string()),
surface_code: ks_lib::MdSurfaceCode(surface.to_string()),
event_code: ks_lib::MdEventCode(format!("{surface}.{entry}")),
event_name: ks_lib::MdEventName(entry.to_string()),
event_family: ks_lib::MdEventFamily::Metadata,
source_kind: ks_lib::MdEventSourceKind::Instruction,
confidence: ks_lib::MdDecoderConfidence::ManualExact,
},
payload_json: serde_json::json!({
"programId": program_id,
@@ -1053,9 +1053,9 @@ mod tests {
transaction_failed: false,
transaction_error: std::option::Option::None,
observation_committed: true,
proof: kb_lib::DcApiDecoderProof {
kind: kb_lib::DcApiDecoderProofKind::Manual,
confidence: kb_lib::MdDecoderConfidence::ManualExact,
proof: ks_lib::DcApiDecoderProof {
kind: ks_lib::DcApiDecoderProofKind::Manual,
confidence: ks_lib::MdDecoderConfidence::ManualExact,
evidence: std::vec!["fixture".to_string()],
},
};
@@ -1114,19 +1114,19 @@ mod tests {
fn metadata_materializer_ownership_is_exact_in_the_runtime_registry() {
for (program_id, surface, entry, expected) in [
(
kb_program_ids::METADATA_METAPLEX_TOKEN_METADATA_PROGRAM_ID,
ks_program_ids::METADATA_METAPLEX_TOKEN_METADATA_PROGRAM_ID,
"metadata.metaplex_token_metadata",
"create_metadata_account_v3",
"materializer.metadata.metaplex_token_metadata",
),
(
kb_program_ids::METADATA_SOLANA_PROGRAM_METADATA_PROGRAM_ID,
ks_program_ids::METADATA_SOLANA_PROGRAM_METADATA_PROGRAM_ID,
"metadata.solana_program_metadata",
"initialize",
"materializer.metadata.solana_program_metadata",
),
(
kb_program_ids::SPL_TOKEN_2022_PROGRAM_ID,
ks_program_ids::SPL_TOKEN_2022_PROGRAM_ID,
"spl.token_2022",
"initialize_token_metadata",
"materializer.metadata.token_2022",
@@ -1274,7 +1274,7 @@ mod tests {
#[test]
fn committed_annotation_row_is_mapped_to_ui_safe_contract() {
let row = kb_store::MaterializedEventQueryRow {
let row = ks_store::MaterializedEventQueryRow {
processor_name: "materializer.transaction.annotations".to_string(),
processor_version: "0.4.3".to_string(),
input_key: "input".to_string(),
@@ -1288,7 +1288,7 @@ mod tests {
payload_json: serde_json::json!({
"instructionPath": "1/0",
"generation": "v4",
"programId": kb_program_ids::SPL_MEMO_V4_PROGRAM_ID,
"programId": ks_program_ids::SPL_MEMO_V4_PROGRAM_ID,
"text": "annotation",
"payloadLengthBytes": 10,
"payloadSha256": "11",
@@ -1310,7 +1310,7 @@ mod tests {
#[test]
fn malformed_annotation_payload_fails_closed() {
let row = kb_store::MaterializedEventQueryRow {
let row = ks_store::MaterializedEventQueryRow {
processor_name: "materializer.transaction.annotations".to_string(),
processor_version: "0.4.3".to_string(),
input_key: "input".to_string(),

4
kb-app-demo-desktop/src/demo_devnet_common.rs
View File

@@ -1,5 +1,5 @@
// file: kb-app-demo-desktop/src/demo_devnet_common.rs
// version: 3
// version: 4
//! Shared Devnet demo UI contracts.
@@ -29,7 +29,7 @@ pub(crate) struct DemoExecutionDevnetStoreReadinessPayload {
/// Converts the reusable scenario readiness report to the desktop TS-RS payload.
pub(crate) fn devnet_store_readiness_payload(
readiness: kb_pipeline_demo_scenarios::DevnetProfileStoreReadiness,
readiness: ks_pipeline_demo_scenarios::DevnetProfileStoreReadiness,
) -> DemoExecutionDevnetStoreReadinessPayload {
return DemoExecutionDevnetStoreReadinessPayload {
profile_name: readiness.profile_name,

18
kb-app-demo-desktop/src/demo_execution_metadata.rs
View File

@@ -1,5 +1,5 @@
// file: kb-app-demo-desktop/src/demo_execution_metadata.rs
// version: 15
// version: 16
//! Shared desktop contracts for metadata execution demos.
@@ -69,8 +69,8 @@ impl crate::DemoExecutionMetadataObserver<'_> {
}
}
impl kb_pipeline::BackfillObserver for crate::DemoExecutionMetadataObserver<'_> {
fn on_progress(&self, event: &kb_pipeline::BackfillProgressEvent) {
impl ks_pipeline::BackfillObserver for crate::DemoExecutionMetadataObserver<'_> {
fn on_progress(&self, event: &ks_pipeline::BackfillProgressEvent) {
self.emit(
event.timestamp.clone(),
event.level.code(),
@@ -85,8 +85,8 @@ impl kb_pipeline::BackfillObserver for crate::DemoExecutionMetadataObserver<'_>
}
}
impl kb_pipeline::CoreExtractionObserver for crate::DemoExecutionMetadataObserver<'_> {
fn on_progress(&self, event: &kb_pipeline::CoreExtractionProgressEvent) {
impl ks_pipeline::CoreExtractionObserver for crate::DemoExecutionMetadataObserver<'_> {
fn on_progress(&self, event: &ks_pipeline::CoreExtractionProgressEvent) {
self.emit(
event.timestamp.clone(),
event.level.code(),
@@ -101,8 +101,8 @@ impl kb_pipeline::CoreExtractionObserver for crate::DemoExecutionMetadataObserve
}
}
impl kb_pipeline::DecodeReplayObserver for crate::DemoExecutionMetadataObserver<'_> {
fn on_progress(&self, event: &kb_pipeline::DecodeReplayProgressEvent) {
impl ks_pipeline::DecodeReplayObserver for crate::DemoExecutionMetadataObserver<'_> {
fn on_progress(&self, event: &ks_pipeline::DecodeReplayProgressEvent) {
self.emit(
event.timestamp.clone(),
event.level.code(),
@@ -117,12 +117,12 @@ impl kb_pipeline::DecodeReplayObserver for crate::DemoExecutionMetadataObserver<
}
}
impl kb_pipeline_demo_scenarios::SolanaExecutionObserver
impl ks_pipeline_demo_scenarios::SolanaExecutionObserver
for crate::DemoExecutionMetadataObserver<'_>
{
fn on_execution_progress(
&self,
event: &kb_pipeline_demo_scenarios::SolanaExecutionProgressEvent,
event: &ks_pipeline_demo_scenarios::SolanaExecutionProgressEvent,
) {
self.emit(
event.timestamp.clone(),

220
kb-app-demo-desktop/src/demo_execution_metadata_metaplex_token_metadata.rs
View File

@@ -1,5 +1,5 @@
// file: kb-app-demo-desktop/src/demo_execution_metadata_metaplex_token_metadata.rs
// version: 6
// version: 7
//! Desktop adapters for generic and qualified Metaplex Token Metadata execution workflows.
@@ -186,7 +186,7 @@ pub(crate) async fn demo_execution_metadata_metaplex_token_metadata_execute(
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
let http_pool = match kb_onchain_transport::HttpEndpointPool::from_profile(&profile) {
let http_pool = match ks_onchain_transport::HttpEndpointPool::from_profile(&profile) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
};
@@ -197,7 +197,7 @@ pub(crate) async fn demo_execution_metadata_metaplex_token_metadata_execute(
if let std::result::Result::Err(error) = store.initialize_store_schema().await {
return std::result::Result::Err(error.to_string());
}
let mut execution_request = match kb_pipeline_demo_scenarios::DevnetMetaplexTokenMetadataExecutionRequest::from_operation_json(
let mut execution_request = match ks_pipeline_demo_scenarios::DevnetMetaplexTokenMetadataExecutionRequest::from_operation_json(
request.intent_id,
request.operation_json.as_str(),
) {
@@ -222,21 +222,21 @@ pub(crate) async fn demo_execution_metadata_metaplex_token_metadata_execute(
if let std::result::Result::Err(error) = execution_request.validate() {
return std::result::Result::Err(error.to_string());
}
let decoders: std::vec::Vec<std::sync::Arc<dyn kb_lib::DcApiInstructionDecoder>> =
std::vec![std::sync::Arc::new(kb_lib::DcMetadataMetaplexTokenMetadataDecoder)];
let materializers: std::vec::Vec<std::sync::Arc<dyn kb_lib::MtApiEventMaterializer>> = std::vec![
std::sync::Arc::new(kb_lib::MtAdminMaterializer),
std::sync::Arc::new(kb_lib::MtComplianceAuditMaterializer),
std::sync::Arc::new(kb_lib::MtLifecycleMaterializer),
std::sync::Arc::new(kb_lib::MtMetadataMetaplexTokenMetadataMaterializer),
std::sync::Arc::new(kb_lib::MtRiskMaterializer),
let decoders: std::vec::Vec<std::sync::Arc<dyn ks_lib::DcApiInstructionDecoder>> =
std::vec![std::sync::Arc::new(ks_lib::DcMetadataMetaplexTokenMetadataDecoder)];
let materializers: std::vec::Vec<std::sync::Arc<dyn ks_lib::MtApiEventMaterializer>> = std::vec![
std::sync::Arc::new(ks_lib::MtAdminMaterializer),
std::sync::Arc::new(ks_lib::MtComplianceAuditMaterializer),
std::sync::Arc::new(ks_lib::MtLifecycleMaterializer),
std::sync::Arc::new(ks_lib::MtMetadataMetaplexTokenMetadataMaterializer),
std::sync::Arc::new(ks_lib::MtRiskMaterializer),
];
let observer = crate::DemoExecutionMetadataObserver {
app_handle,
cancel_requested: state.demo_execution_solana_core_cancel_requested(),
};
let workspace_root = crate::workspace_root_dir();
let summary = match kb_pipeline_demo_scenarios::execute_devnet_metaplex_token_metadata(
let summary = match ks_pipeline_demo_scenarios::execute_devnet_metaplex_token_metadata(
&http_pool,
&store,
&profile,
@@ -290,7 +290,7 @@ pub(crate) async fn demo_execution_metadata_metaplex_token_metadata_execute(
);
}
fn backfill_summary_json(summary: &kb_pipeline::BackfillSummary) -> serde_json::Value {
fn backfill_summary_json(summary: &ks_pipeline::BackfillSummary) -> serde_json::Value {
return serde_json::json!({
"captureSessionId": summary.capture_session_id,
"filterCode": summary.filter_code,
@@ -318,7 +318,7 @@ fn backfill_summary_json(summary: &kb_pipeline::BackfillSummary) -> serde_json::
});
}
fn core_extraction_summary_json(summary: &kb_pipeline::CoreExtractionSummary) -> serde_json::Value {
fn core_extraction_summary_json(summary: &ks_pipeline::CoreExtractionSummary) -> serde_json::Value {
return serde_json::json!({
"processorVersion": summary.processor_version,
"selected": summary.selected,
@@ -335,7 +335,7 @@ fn core_extraction_summary_json(summary: &kb_pipeline::CoreExtractionSummary) ->
});
}
fn decode_replay_summary_json(summary: &kb_pipeline::DecodeReplaySummary) -> serde_json::Value {
fn decode_replay_summary_json(summary: &ks_pipeline::DecodeReplaySummary) -> serde_json::Value {
let processors = summary
.processors
.iter()
@@ -375,7 +375,7 @@ fn decode_replay_summary_json(summary: &kb_pipeline::DecodeReplaySummary) -> ser
fn parse_stateful_reads(
value: &str,
) -> std::result::Result<
std::vec::Vec<kb_pipeline::MetaplexTokenMetadataStatefulReadRequest>,
std::vec::Vec<ks_pipeline::MetaplexTokenMetadataStatefulReadRequest>,
std::string::String,
> {
if value.trim().is_empty() {
@@ -400,7 +400,7 @@ pub(crate) async fn demo_execution_metadata_metaplex_token_metadata_prepare_crea
return prepare_create_fixture_for_family(
state,
profile_name,
kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Nft,
ks_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Nft,
)
.await;
}
@@ -408,7 +408,7 @@ pub(crate) async fn demo_execution_metadata_metaplex_token_metadata_prepare_crea
async fn prepare_create_fixture_for_family(
state: tauri::State<'_, crate::AppState>,
profile_name: std::string::String,
asset_family: kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily,
asset_family: ks_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily,
) -> std::result::Result<
crate::DemoExecutionMetadataMetaplexTokenMetadataCreateFixturePayload,
std::string::String,
@@ -423,15 +423,15 @@ async fn prepare_create_fixture_for_family(
} else {
crate::workspace_root_dir().join(configured)
};
let http_pool = match kb_onchain_transport::HttpEndpointPool::from_profile(&profile) {
let http_pool = match ks_onchain_transport::HttpEndpointPool::from_profile(&profile) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
};
let workspace_root = crate::workspace_root_dir();
let options =
kb_pipeline_demo_scenarios::MetaplexCreateFixturePreparationOptions::new(wallet_dir)
ks_pipeline_demo_scenarios::MetaplexCreateFixturePreparationOptions::new(wallet_dir)
.with_asset_family(asset_family);
let summary = match kb_pipeline_demo_scenarios::prepare_metaplex_create_fixture(
let summary = match ks_pipeline_demo_scenarios::prepare_metaplex_create_fixture(
&http_pool,
&profile,
workspace_root.as_path(),
@@ -465,7 +465,7 @@ pub(crate) async fn demo_execution_metadata_metaplex_token_metadata_prepare_step
crate::DemoExecutionMetadataMetaplexTokenMetadataPreparedStepPayload,
std::string::String,
> {
let scenario = kb_pipeline_demo_scenarios::metaplex_token_metadata_devnet_scenarios()
let scenario = ks_pipeline_demo_scenarios::metaplex_token_metadata_devnet_scenarios()
.into_iter()
.find(|candidate| return candidate.id == scenario_id);
let scenario = match scenario {
@@ -566,7 +566,7 @@ pub(crate) async fn demo_execution_metadata_metaplex_token_metadata_prepare_step
std::option::Option::None => std::string::String::new(),
};
let immutable_transition = scenario.asset_family
== kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Nft
== ks_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Nft
&& step_index == 2;
let value = serde_json::json!({
"operation": "update_as_update_authority_v2",
@@ -633,9 +633,9 @@ pub(crate) async fn demo_execution_metadata_metaplex_token_metadata_prepare_step
};
let create_reads_edition = matches!(
scenario.asset_family,
kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Nft
| kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Collection
| kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::ProgrammableNft
ks_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Nft
| ks_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Collection
| ks_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::ProgrammableNft
);
let postcondition_reads = if operation == "create" && create_reads_edition {
serde_json::json!([metadata_read, edition_read])
@@ -648,7 +648,7 @@ pub(crate) async fn demo_execution_metadata_metaplex_token_metadata_prepare_step
step_index,
operation: operation.clone(),
label: if scenario.asset_family
== kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Nft
== ks_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Nft
&& step_index == 2
{
"Étape 3 — rendre les metadata immutables".to_string()
@@ -668,7 +668,7 @@ pub(crate) async fn demo_execution_metadata_metaplex_token_metadata_prepare_step
/// Returns current operation names accepted by automatic Devnet campaigns.
pub(crate) fn demo_execution_metadata_metaplex_token_metadata_current_operations()
-> std::vec::Vec<std::string::String> {
return kb_pipeline_demo_scenarios::metaplex_token_metadata_current_operation_names()
return ks_pipeline_demo_scenarios::metaplex_token_metadata_current_operation_names()
.iter()
.map(|value| return (*value).to_string())
.collect();
@@ -678,7 +678,7 @@ pub(crate) fn demo_execution_metadata_metaplex_token_metadata_current_operations
pub(crate) fn demo_execution_metadata_metaplex_token_metadata_operation_template(
operation: std::string::String,
) -> std::result::Result<std::string::String, std::string::String> {
return match kb_pipeline_demo_scenarios::metaplex_token_metadata_current_operation_json_template(
return match ks_pipeline_demo_scenarios::metaplex_token_metadata_current_operation_json_template(
operation.as_str(),
) {
std::result::Result::Ok(value) => std::result::Result::Ok(value),
@@ -691,7 +691,7 @@ pub(crate) fn demo_execution_metadata_metaplex_token_metadata_scenarios() -> std
std::vec::Vec<crate::DemoExecutionMetadataMetaplexTokenMetadataScenarioPayload>,
std::string::String,
> {
let matrix = match kb_pipeline_demo_scenarios::load_metaplex_token_metadata_validation_matrix()
let matrix = match ks_pipeline_demo_scenarios::load_metaplex_token_metadata_validation_matrix()
{
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
@@ -703,14 +703,14 @@ pub(crate) fn demo_execution_metadata_metaplex_token_metadata_scenarios() -> std
.collect::<std::collections::BTreeMap<
std::string::String,
(
kb_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus,
ks_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus,
std::vec::Vec<std::string::String>,
),
>>();
let mut payloads = std::vec::Vec::new();
for scenario in kb_pipeline_demo_scenarios::metaplex_token_metadata_synthetic_scenarios()
for scenario in ks_pipeline_demo_scenarios::metaplex_token_metadata_synthetic_scenarios()
.into_iter()
.chain(kb_pipeline_demo_scenarios::metaplex_token_metadata_devnet_scenarios())
.chain(ks_pipeline_demo_scenarios::metaplex_token_metadata_devnet_scenarios())
{
let status = statuses.get(scenario.id.as_str());
let validation_status = match status {
@@ -742,74 +742,74 @@ pub(crate) fn demo_execution_metadata_metaplex_token_metadata_scenarios() -> std
}
fn asset_family_code(
value: kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily,
value: ks_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily,
) -> std::string::String {
return match value {
kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Nft => "nft".to_string(),
kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Sft => "sft".to_string(),
kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Fungible => {
ks_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Nft => "nft".to_string(),
ks_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Sft => "sft".to_string(),
ks_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Fungible => {
"fungible".to_string()
},
kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Collection => {
ks_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Collection => {
"collection".to_string()
},
kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::ProgrammableNft => {
ks_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::ProgrammableNft => {
"programmable_nft".to_string()
},
};
}
fn fixture_kind_code(
value: kb_pipeline_demo_scenarios::MetaplexTokenMetadataFixtureKind,
value: ks_pipeline_demo_scenarios::MetaplexTokenMetadataFixtureKind,
) -> std::string::String {
return format!("{value:?}").to_lowercase();
}
fn fixture_state_code(
value: kb_pipeline_demo_scenarios::MetaplexTokenMetadataFixtureState,
value: ks_pipeline_demo_scenarios::MetaplexTokenMetadataFixtureState,
) -> std::string::String {
return format!("{value:?}").to_lowercase();
}
fn scenario_mode_code(
value: kb_pipeline_demo_scenarios::MetaplexTokenMetadataScenarioMode,
value: ks_pipeline_demo_scenarios::MetaplexTokenMetadataScenarioMode,
) -> std::string::String {
return match value {
kb_pipeline_demo_scenarios::MetaplexTokenMetadataScenarioMode::Synthetic => {
ks_pipeline_demo_scenarios::MetaplexTokenMetadataScenarioMode::Synthetic => {
"synthetic".to_string()
},
kb_pipeline_demo_scenarios::MetaplexTokenMetadataScenarioMode::NetworkSimulation => {
ks_pipeline_demo_scenarios::MetaplexTokenMetadataScenarioMode::NetworkSimulation => {
"network_simulation".to_string()
},
kb_pipeline_demo_scenarios::MetaplexTokenMetadataScenarioMode::NetworkSubmission => {
ks_pipeline_demo_scenarios::MetaplexTokenMetadataScenarioMode::NetworkSubmission => {
"network_submission".to_string()
},
};
}
fn validation_status_code(
value: kb_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus,
value: ks_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus,
) -> std::string::String {
return match value {
kb_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus::NotRun => {
ks_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus::NotRun => {
"not_run".to_string()
},
kb_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus::SyntheticValidated => {
ks_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus::SyntheticValidated => {
"synthetic_validated".to_string()
},
kb_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus::Simulated => {
ks_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus::Simulated => {
"simulated".to_string()
},
kb_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus::Submitted => {
ks_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus::Submitted => {
"submitted".to_string()
},
kb_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus::Confirmed => {
ks_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus::Confirmed => {
"confirmed".to_string()
},
kb_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus::Unavailable => {
ks_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus::Unavailable => {
"unavailable".to_string()
},
kb_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus::Failed => {
ks_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus::Failed => {
"failed".to_string()
},
};
@@ -895,7 +895,7 @@ struct CampaignProjection {
type CampaignProjectionFuture<'a> = std::pin::Pin<
std::boxed::Box<
dyn std::future::Future<Output = kb_core::Result<CampaignProjection>>
dyn std::future::Future<Output = ks_core::Result<CampaignProjection>>
+ std::marker::Send
+ 'a,
>,
@@ -917,7 +917,7 @@ pub(crate) fn demo_execution_metadata_metaplex_campaigns()
label: label.to_string(),
asset_family: family.to_string(),
operation_names:
kb_pipeline_demo_scenarios::metaplex_create_mint_campaign_operation_names()
ks_pipeline_demo_scenarios::metaplex_create_mint_campaign_operation_names()
.iter()
.map(|value| return (*value).to_string())
.collect(),
@@ -930,7 +930,7 @@ pub(crate) fn demo_execution_metadata_metaplex_campaigns()
"collection_verify",
"Collection — Verify → Unverify",
"collection",
kb_pipeline_demo_scenarios::metaplex_collection_verify_campaign_operation_names(),
ks_pipeline_demo_scenarios::metaplex_collection_verify_campaign_operation_names(),
"confirmed",
"fresh collection parent + fresh unverified member",
),
@@ -938,7 +938,7 @@ pub(crate) fn demo_execution_metadata_metaplex_campaigns()
"print_burn",
"NFT imprimable — Print → Burn",
"nft",
kb_pipeline_demo_scenarios::metaplex_print_burn_campaign_operation_names(),
ks_pipeline_demo_scenarios::metaplex_print_burn_campaign_operation_names(),
"confirmed",
"fresh limited-supply master NFT + fresh printed edition",
),
@@ -946,7 +946,7 @@ pub(crate) fn demo_execution_metadata_metaplex_campaigns()
"pnft_lifecycle",
"pNFT — Delegate → Lock → Unlock → Revoke → Delegate → Transfer",
"programmable_nft",
kb_pipeline_demo_scenarios::metaplex_pnft_lifecycle_campaign_operation_names(),
ks_pipeline_demo_scenarios::metaplex_pnft_lifecycle_campaign_operation_names(),
"confirmed",
"fresh pNFT + delegate wallet + destination owner",
),
@@ -954,7 +954,7 @@ pub(crate) fn demo_execution_metadata_metaplex_campaigns()
"escrow",
"Token Owned Escrow — Create → TransferOut → Close",
"nft",
kb_pipeline_demo_scenarios::metaplex_escrow_campaign_operation_names(),
ks_pipeline_demo_scenarios::metaplex_escrow_campaign_operation_names(),
"confirmed",
"fresh NFT parent + fresh fungible attribute + escrow ATA deposit",
),
@@ -962,7 +962,7 @@ pub(crate) fn demo_execution_metadata_metaplex_campaigns()
"maintenance",
"Maintenance — Update + probes réservés/legacy",
"nft",
kb_pipeline_demo_scenarios::metaplex_maintenance_campaign_operation_names(),
ks_pipeline_demo_scenarios::metaplex_maintenance_campaign_operation_names(),
"mixed_confirmed_unavailable",
"fresh NFT; Update submitted; Resize/Migrate/Collect/CloseAccounts simulation-only probes",
),
@@ -970,7 +970,7 @@ pub(crate) fn demo_execution_metadata_metaplex_campaigns()
"use_probe",
"Use — probe runtime",
"nft",
kb_pipeline_demo_scenarios::metaplex_use_probe_operation_names(),
ks_pipeline_demo_scenarios::metaplex_use_probe_operation_names(),
"runtime_unavailable_probe",
"fresh NFT with two bounded Multiple uses; Use is simulation-only when rejected",
),
@@ -1036,7 +1036,7 @@ pub(crate) async fn demo_execution_metadata_metaplex_execute_campaign(
.to_string(),
);
}
let http_pool = match kb_onchain_transport::HttpEndpointPool::from_profile(&profile) {
let http_pool = match ks_onchain_transport::HttpEndpointPool::from_profile(&profile) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
};
@@ -1131,19 +1131,19 @@ pub(crate) async fn demo_execution_metadata_metaplex_execute_campaign(
fn execute_campaign_projection<'a, S, O>(
campaign_id: &'a str,
wallet_dir: std::path::PathBuf,
http_pool: &'a kb_onchain_transport::HttpEndpointPool,
http_pool: &'a ks_onchain_transport::HttpEndpointPool,
store: &'a S,
profile: &'a kb_config::ProfileConfig,
profile: &'a ks_config::ProfileConfig,
workspace_root: &'a std::path::Path,
observer: &'a O,
) -> CampaignProjectionFuture<'a>
where
S: kb_store::RawTransactionStore
+ kb_store::CoreExtractionStore
+ kb_store::DecodePipelineStore
S: ks_store::RawTransactionStore
+ ks_store::CoreExtractionStore
+ ks_store::DecodePipelineStore
+ Sync
+ 'a,
O: kb_pipeline_demo_scenarios::SolanaExecutionObserver + 'a,
O: ks_pipeline_demo_scenarios::SolanaExecutionObserver + 'a,
{
return std::boxed::Box::pin(execute_campaign_projection_unboxed(
campaign_id,
@@ -1159,27 +1159,27 @@ where
async fn execute_campaign_projection_unboxed<S, O>(
campaign_id: &str,
wallet_dir: std::path::PathBuf,
http_pool: &kb_onchain_transport::HttpEndpointPool,
http_pool: &ks_onchain_transport::HttpEndpointPool,
store: &S,
profile: &kb_config::ProfileConfig,
profile: &ks_config::ProfileConfig,
workspace_root: &std::path::Path,
observer: &O,
) -> kb_core::Result<CampaignProjection>
) -> ks_core::Result<CampaignProjection>
where
S: kb_store::RawTransactionStore
+ kb_store::CoreExtractionStore
+ kb_store::DecodePipelineStore
S: ks_store::RawTransactionStore
+ ks_store::CoreExtractionStore
+ ks_store::DecodePipelineStore
+ Sync,
O: kb_pipeline_demo_scenarios::SolanaExecutionObserver,
O: ks_pipeline_demo_scenarios::SolanaExecutionObserver,
{
let base_options =
kb_pipeline_demo_scenarios::MetaplexCreateFixturePreparationOptions::new(wallet_dir);
ks_pipeline_demo_scenarios::MetaplexCreateFixturePreparationOptions::new(wallet_dir);
return match campaign_id {
"create_mint_nft" => {
execute_create_mint_projection(
"Create → Mint — NFT",
base_options.clone().with_asset_family(
kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Nft,
ks_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Nft,
),
http_pool,
store,
@@ -1193,7 +1193,7 @@ where
execute_create_mint_projection(
"Create → Mint — SFT",
base_options.clone().with_asset_family(
kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Sft,
ks_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Sft,
),
http_pool,
store,
@@ -1207,7 +1207,7 @@ where
execute_create_mint_projection(
"Create → Mint — Fungible",
base_options.clone().with_asset_family(
kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Fungible,
ks_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Fungible,
),
http_pool,
store,
@@ -1221,7 +1221,7 @@ where
execute_create_mint_projection(
"Create → Mint — Collection",
base_options.clone().with_asset_family(
kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Collection,
ks_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Collection,
),
http_pool,
store,
@@ -1235,7 +1235,7 @@ where
execute_create_mint_projection(
"Create → Mint — pNFT",
base_options.clone().with_asset_family(
kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::ProgrammableNft,
ks_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::ProgrammableNft,
),
http_pool,
store,
@@ -1246,7 +1246,7 @@ where
.await
},
"collection_verify" => {
let summary = match kb_pipeline_demo_scenarios::execute_devnet_metaplex_collection_verify_campaign(
let summary = match ks_pipeline_demo_scenarios::execute_devnet_metaplex_collection_verify_campaign(
http_pool,
store,
profile,
@@ -1285,7 +1285,7 @@ where
},
"print_burn" => {
let summary =
match kb_pipeline_demo_scenarios::execute_devnet_metaplex_print_burn_campaign(
match ks_pipeline_demo_scenarios::execute_devnet_metaplex_print_burn_campaign(
http_pool,
store,
profile,
@@ -1324,10 +1324,10 @@ where
},
"pnft_lifecycle" => {
let options = base_options.clone().with_asset_family(
kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::ProgrammableNft,
ks_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::ProgrammableNft,
);
let summary =
match kb_pipeline_demo_scenarios::execute_devnet_metaplex_pnft_lifecycle_campaign(
match ks_pipeline_demo_scenarios::execute_devnet_metaplex_pnft_lifecycle_campaign(
http_pool,
store,
profile,
@@ -1361,7 +1361,7 @@ where
})
},
"escrow" => {
let summary = match kb_pipeline_demo_scenarios::execute_devnet_metaplex_escrow_campaign(
let summary = match ks_pipeline_demo_scenarios::execute_devnet_metaplex_escrow_campaign(
http_pool,
store,
profile,
@@ -1407,10 +1407,10 @@ where
},
"maintenance" => {
let options = base_options.clone().with_asset_family(
kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Nft,
ks_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Nft,
);
let summary =
match kb_pipeline_demo_scenarios::execute_devnet_metaplex_maintenance_campaign(
match ks_pipeline_demo_scenarios::execute_devnet_metaplex_maintenance_campaign(
http_pool,
store,
profile,
@@ -1463,9 +1463,9 @@ where
},
"use_probe" => {
let options = base_options.clone().with_asset_family(
kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Nft,
ks_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Nft,
);
let summary = match kb_pipeline_demo_scenarios::execute_devnet_metaplex_use_probe(
let summary = match ks_pipeline_demo_scenarios::execute_devnet_metaplex_use_probe(
http_pool,
store,
profile,
@@ -1501,7 +1501,7 @@ where
}),
})
},
_ => std::result::Result::Err(kb_core::Error::config(format!(
_ => std::result::Result::Err(ks_core::Error::config(format!(
"unknown qualified Metaplex desktop campaign `{campaign_id}`"
))),
};
@@ -1509,21 +1509,21 @@ where
async fn execute_create_mint_projection<S, O>(
label: &str,
options: kb_pipeline_demo_scenarios::MetaplexCreateFixturePreparationOptions,
http_pool: &kb_onchain_transport::HttpEndpointPool,
options: ks_pipeline_demo_scenarios::MetaplexCreateFixturePreparationOptions,
http_pool: &ks_onchain_transport::HttpEndpointPool,
store: &S,
profile: &kb_config::ProfileConfig,
profile: &ks_config::ProfileConfig,
workspace_root: &std::path::Path,
observer: &O,
) -> kb_core::Result<CampaignProjection>
) -> ks_core::Result<CampaignProjection>
where
S: kb_store::RawTransactionStore
+ kb_store::CoreExtractionStore
+ kb_store::DecodePipelineStore
S: ks_store::RawTransactionStore
+ ks_store::CoreExtractionStore
+ ks_store::DecodePipelineStore
+ Sync,
O: kb_pipeline_demo_scenarios::SolanaExecutionObserver,
O: ks_pipeline_demo_scenarios::SolanaExecutionObserver,
{
let summary = match kb_pipeline_demo_scenarios::execute_devnet_metaplex_create_mint_campaign(
let summary = match ks_pipeline_demo_scenarios::execute_devnet_metaplex_create_mint_campaign(
http_pool,
store,
profile,
@@ -1554,7 +1554,7 @@ where
fn metaplex_execution_json(
label: &str,
summary: &kb_pipeline_demo_scenarios::DevnetMetaplexTokenMetadataExecutionSummary,
summary: &ks_pipeline_demo_scenarios::DevnetMetaplexTokenMetadataExecutionSummary,
) -> serde_json::Value {
let classification = if execution_confirmation_is_confirmed(&summary.confirmation) {
"confirmed"
@@ -1594,13 +1594,13 @@ fn metaplex_execution_json(
}
fn execution_confirmation_is_confirmed(
confirmation: &std::option::Option<kb_lib::ExApiExecutionConfirmationResult>,
confirmation: &std::option::Option<ks_lib::ExApiExecutionConfirmationResult>,
) -> bool {
return confirmation.as_ref().is_some_and(|value| {
return matches!(
value.status,
kb_lib::ExApiExecutionConfirmationStatus::Confirmed
| kb_lib::ExApiExecutionConfirmationStatus::Finalized
ks_lib::ExApiExecutionConfirmationStatus::Confirmed
| ks_lib::ExApiExecutionConfirmationStatus::Finalized
);
});
}
@@ -1611,7 +1611,7 @@ fn execution_is_confirmed_json(value: &serde_json::Value) -> bool {
}
fn create_mint_state_json(
state: &kb_pipeline_demo_scenarios::DevnetMetaplexCreateMintTokenState,
state: &ks_pipeline_demo_scenarios::DevnetMetaplexCreateMintTokenState,
) -> serde_json::Value {
return serde_json::json!({
"expectedAmountRaw": state.expected_amount_raw,
@@ -1625,7 +1625,7 @@ fn create_mint_state_json(
}
fn print_burn_state_json(
state: &kb_pipeline_demo_scenarios::DevnetMetaplexPrintBurnState,
state: &ks_pipeline_demo_scenarios::DevnetMetaplexPrintBurnState,
) -> serde_json::Value {
return serde_json::json!({
"editionNumber": state.edition_number,
@@ -1648,7 +1648,7 @@ fn print_burn_state_json(
}
fn pnft_state_json(
state: &kb_pipeline_demo_scenarios::DevnetMetaplexPnftLifecycleState,
state: &ks_pipeline_demo_scenarios::DevnetMetaplexPnftLifecycleState,
) -> serde_json::Value {
return serde_json::json!({
"delegate": &state.delegate,
@@ -1671,7 +1671,7 @@ fn pnft_state_json(
}
fn escrow_state_json(
state: &kb_pipeline_demo_scenarios::DevnetMetaplexEscrowCampaignState,
state: &ks_pipeline_demo_scenarios::DevnetMetaplexEscrowCampaignState,
) -> serde_json::Value {
return serde_json::json!({
"depositAmountRaw": state.deposit_amount_raw,
@@ -1697,8 +1697,8 @@ mod tests {
},
};
let expected_count =
kb_pipeline_demo_scenarios::metaplex_token_metadata_synthetic_scenarios().len()
+ kb_pipeline_demo_scenarios::metaplex_token_metadata_devnet_scenarios().len();
ks_pipeline_demo_scenarios::metaplex_token_metadata_synthetic_scenarios().len()
+ ks_pipeline_demo_scenarios::metaplex_token_metadata_devnet_scenarios().len();
assert_eq!(payloads.len(), expected_count);
assert!(payloads.iter().all(|payload| return !payload.operation_codes.is_empty()));
assert!(payloads.iter().all(|payload| return payload.requires_postcondition));

36
kb-app-demo-desktop/src/demo_execution_metadata_solana_program.rs
View File

@@ -1,5 +1,5 @@
// file: kb-app-demo-desktop/src/demo_execution_metadata_solana_program.rs
// version: 2
// version: 3
//! Thin desktop adapter for complete Solana Program Metadata Devnet campaigns.
@@ -98,7 +98,7 @@ pub(crate) struct DemoExecutionMetadataSolanaProgramCampaignSummaryPayload {
/// Returns the two canonical Solana Program Metadata Devnet journeys.
pub(crate) fn demo_execution_metadata_solana_program_scenarios()
-> std::vec::Vec<crate::DemoExecutionMetadataSolanaProgramScenarioPayload> {
return kb_pipeline_demo_scenarios::solana_program_metadata_devnet_scenarios()
return ks_pipeline_demo_scenarios::solana_program_metadata_devnet_scenarios()
.into_iter()
.map(|scenario| {
return crate::DemoExecutionMetadataSolanaProgramScenarioPayload {
@@ -159,19 +159,19 @@ pub(crate) async fn demo_execution_metadata_solana_program_execute_campaign(
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
let http_pool = match kb_onchain_transport::HttpEndpointPool::from_profile(&profile) {
let http_pool = match ks_onchain_transport::HttpEndpointPool::from_profile(&profile) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
};
let mut options =
kb_pipeline_demo_scenarios::SolanaProgramMetadataFixturePreparationOptions::new();
ks_pipeline_demo_scenarios::SolanaProgramMetadataFixturePreparationOptions::new();
options.operator_confirmed = true;
let observer = crate::DemoExecutionMetadataObserver {
app_handle,
cancel_requested: state.demo_execution_solana_core_cancel_requested(),
};
let workspace_root = crate::workspace_root_dir();
let summary = match kb_pipeline_demo_scenarios::execute_devnet_solana_program_metadata_campaign(
let summary = match ks_pipeline_demo_scenarios::execute_devnet_solana_program_metadata_campaign(
&http_pool,
&profile,
workspace_root.as_path(),
@@ -187,7 +187,7 @@ pub(crate) async fn demo_execution_metadata_solana_program_execute_campaign(
}
fn campaign_summary_payload(
summary: kb_pipeline_demo_scenarios::DevnetSolanaProgramMetadataCampaignSummary,
summary: ks_pipeline_demo_scenarios::DevnetSolanaProgramMetadataCampaignSummary,
) -> crate::DemoExecutionMetadataSolanaProgramCampaignSummaryPayload {
let mut confirmed_step_count = 0_usize;
let mut materialized_snapshot_count = 0_usize;
@@ -201,8 +201,8 @@ fn campaign_summary_payload(
let confirmed = match step.execution.confirmation.as_ref() {
std::option::Option::Some(value) => matches!(
value.status,
kb_lib::ExApiExecutionConfirmationStatus::Confirmed
| kb_lib::ExApiExecutionConfirmationStatus::Finalized
ks_lib::ExApiExecutionConfirmationStatus::Confirmed
| ks_lib::ExApiExecutionConfirmationStatus::Finalized
),
std::option::Option::None => false,
};
@@ -235,7 +235,7 @@ fn campaign_summary_payload(
"materializedSnapshots": &step.execution.materialized_snapshots
}));
}
let expected_step_count = kb_lib::EX_METADATA_SPM_SUPPORTED_OPERATION_CODES.len();
let expected_step_count = ks_lib::EX_METADATA_SPM_SUPPORTED_OPERATION_CODES.len();
let completed = summary.steps.len() == expected_step_count
&& confirmed_step_count == expected_step_count
&& summary.steps.iter().all(|step| {
@@ -246,7 +246,7 @@ fn campaign_summary_payload(
.find(|prepared| return prepared.step_id == step.step_id)
{
std::option::Option::Some(prepared) => {
prepared.operation.operation_code() == kb_lib::EX_METADATA_SPM_CLOSE_OPERATION
prepared.operation.operation_code() == ks_lib::EX_METADATA_SPM_CLOSE_OPERATION
},
std::option::Option::None => false,
};
@@ -285,22 +285,22 @@ fn campaign_summary_payload(
}
fn fixture_state_code(
value: kb_pipeline_demo_scenarios::SolanaProgramMetadataFixtureState,
value: ks_pipeline_demo_scenarios::SolanaProgramMetadataFixtureState,
) -> std::string::String {
return match value {
kb_pipeline_demo_scenarios::SolanaProgramMetadataFixtureState::Prefunded => {
ks_pipeline_demo_scenarios::SolanaProgramMetadataFixtureState::Prefunded => {
"prefunded".to_string()
},
kb_pipeline_demo_scenarios::SolanaProgramMetadataFixtureState::Buffer => {
ks_pipeline_demo_scenarios::SolanaProgramMetadataFixtureState::Buffer => {
"buffer".to_string()
},
kb_pipeline_demo_scenarios::SolanaProgramMetadataFixtureState::MutableMetadata => {
ks_pipeline_demo_scenarios::SolanaProgramMetadataFixtureState::MutableMetadata => {
"mutable_metadata".to_string()
},
kb_pipeline_demo_scenarios::SolanaProgramMetadataFixtureState::ImmutableMetadata => {
ks_pipeline_demo_scenarios::SolanaProgramMetadataFixtureState::ImmutableMetadata => {
"immutable_metadata".to_string()
},
kb_pipeline_demo_scenarios::SolanaProgramMetadataFixtureState::Closed => {
ks_pipeline_demo_scenarios::SolanaProgramMetadataFixtureState::Closed => {
"closed".to_string()
},
};
@@ -314,11 +314,11 @@ mod tests {
assert_eq!(payloads.len(), 2);
assert_eq!(
payloads.iter().map(|scenario| return scenario.steps.len()).sum::<usize>(),
kb_lib::EX_METADATA_SPM_SUPPORTED_OPERATION_CODES.len()
ks_lib::EX_METADATA_SPM_SUPPORTED_OPERATION_CODES.len()
);
assert!(payloads.iter().flat_map(|scenario| return scenario.steps.iter()).all(|step| {
return !step.required_evidence.is_empty()
&& kb_lib::EX_METADATA_SPM_SUPPORTED_OPERATION_CODES
&& ks_lib::EX_METADATA_SPM_SUPPORTED_OPERATION_CODES
.contains(&step.operation_code.as_str());
}));
}

20
kb-app-demo-desktop/src/demo_execution_metadata_token_2022.rs
View File

@@ -1,5 +1,5 @@
// file: kb-app-demo-desktop/src/demo_execution_metadata_token_2022.rs
// version: 1
// version: 2
//! Thin desktop adapter for the complete Token-2022 Token Metadata Devnet campaign.
@@ -84,7 +84,7 @@ pub(crate) async fn demo_execution_metadata_token_2022_execute_campaign(
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
let http_pool = match kb_onchain_transport::HttpEndpointPool::from_profile(&profile) {
let http_pool = match ks_onchain_transport::HttpEndpointPool::from_profile(&profile) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
};
@@ -103,13 +103,13 @@ pub(crate) async fn demo_execution_metadata_token_2022_execute_campaign(
workspace_root.join(configured_wallet_dir)
};
let mut options =
kb_pipeline_demo_scenarios::Token2022MetadataFixturePreparationOptions::new(wallet_dir);
ks_pipeline_demo_scenarios::Token2022MetadataFixturePreparationOptions::new(wallet_dir);
options.operator_confirmed = true;
let observer = crate::DemoExecutionMetadataObserver {
app_handle,
cancel_requested: state.demo_execution_solana_core_cancel_requested(),
};
let summary = match kb_pipeline_demo_scenarios::execute_devnet_token_2022_metadata_campaign(
let summary = match ks_pipeline_demo_scenarios::execute_devnet_token_2022_metadata_campaign(
&http_pool,
&store,
&profile,
@@ -127,7 +127,7 @@ pub(crate) async fn demo_execution_metadata_token_2022_execute_campaign(
fn campaign_summary_payload(
profile_name: std::string::String,
summary: kb_pipeline_demo_scenarios::DevnetToken2022MetadataCampaignSummary,
summary: ks_pipeline_demo_scenarios::DevnetToken2022MetadataCampaignSummary,
) -> crate::DemoExecutionMetadataToken2022CampaignSummaryPayload {
let mut confirmed_step_count = 0_usize;
let mut materialization_count = 0_usize;
@@ -136,8 +136,8 @@ fn campaign_summary_payload(
let confirmed = match step.execution.confirmation.as_ref() {
std::option::Option::Some(value) => matches!(
value.status,
kb_lib::ExApiExecutionConfirmationStatus::Confirmed
| kb_lib::ExApiExecutionConfirmationStatus::Finalized
ks_lib::ExApiExecutionConfirmationStatus::Confirmed
| ks_lib::ExApiExecutionConfirmationStatus::Finalized
),
std::option::Option::None => false,
};
@@ -161,12 +161,12 @@ fn campaign_summary_payload(
}));
}
let expected_step_count =
kb_pipeline_demo_scenarios::token_2022_metadata_campaign_operation_names().len();
ks_pipeline_demo_scenarios::token_2022_metadata_campaign_operation_names().len();
let completed = summary.steps.len() == expected_step_count
&& confirmed_step_count == expected_step_count
&& summary.steps.iter().all(|step| {
return step.postcondition.status
== kb_pipeline::Token2022ExecutionPostconditionStatus::Confirmed;
== ks_pipeline::Token2022ExecutionPostconditionStatus::Confirmed;
});
let fixture_json = crate::pretty_json(&serde_json::json!({
"mint": &summary.fixture.mint,
@@ -198,7 +198,7 @@ mod tests {
#[test]
fn desktop_campaign_exposes_the_exact_five_token_metadata_operations() {
assert_eq!(
kb_pipeline_demo_scenarios::token_2022_metadata_campaign_operation_names(),
ks_pipeline_demo_scenarios::token_2022_metadata_campaign_operation_names(),
&[
"initialize_token_metadata",
"update_token_metadata_field",

100
kb-app-demo-desktop/src/demo_execution_solana_core.rs
View File

@@ -1,5 +1,5 @@
// file: kb-app-demo-desktop/src/demo_execution_solana_core.rs
// version: 13
// version: 14
//! Tauri adapter for bounded Solana Core execution on Devnet.
@@ -290,8 +290,8 @@ impl crate::DemoExecutionSolanaCoreObserver<'_> {
}
}
impl kb_pipeline::BackfillObserver for crate::DemoExecutionSolanaCoreObserver<'_> {
fn on_progress(&self, event: &kb_pipeline::BackfillProgressEvent) {
impl ks_pipeline::BackfillObserver for crate::DemoExecutionSolanaCoreObserver<'_> {
fn on_progress(&self, event: &ks_pipeline::BackfillProgressEvent) {
self.emit(
event.timestamp.clone(),
event.level.code(),
@@ -306,8 +306,8 @@ impl kb_pipeline::BackfillObserver for crate::DemoExecutionSolanaCoreObserver<'_
}
}
impl kb_pipeline::CoreExtractionObserver for crate::DemoExecutionSolanaCoreObserver<'_> {
fn on_progress(&self, event: &kb_pipeline::CoreExtractionProgressEvent) {
impl ks_pipeline::CoreExtractionObserver for crate::DemoExecutionSolanaCoreObserver<'_> {
fn on_progress(&self, event: &ks_pipeline::CoreExtractionProgressEvent) {
self.emit(
event.timestamp.clone(),
event.level.code(),
@@ -322,8 +322,8 @@ impl kb_pipeline::CoreExtractionObserver for crate::DemoExecutionSolanaCoreObser
}
}
impl kb_pipeline::DecodeReplayObserver for crate::DemoExecutionSolanaCoreObserver<'_> {
fn on_progress(&self, event: &kb_pipeline::DecodeReplayProgressEvent) {
impl ks_pipeline::DecodeReplayObserver for crate::DemoExecutionSolanaCoreObserver<'_> {
fn on_progress(&self, event: &ks_pipeline::DecodeReplayProgressEvent) {
self.emit(
event.timestamp.clone(),
event.level.code(),
@@ -338,12 +338,12 @@ impl kb_pipeline::DecodeReplayObserver for crate::DemoExecutionSolanaCoreObserve
}
}
impl kb_pipeline_demo_scenarios::SolanaExecutionObserver
impl ks_pipeline_demo_scenarios::SolanaExecutionObserver
for crate::DemoExecutionSolanaCoreObserver<'_>
{
fn on_execution_progress(
&self,
event: &kb_pipeline_demo_scenarios::SolanaExecutionProgressEvent,
event: &ks_pipeline_demo_scenarios::SolanaExecutionProgressEvent,
) {
self.emit(
event.timestamp.clone(),
@@ -360,10 +360,10 @@ impl kb_pipeline_demo_scenarios::SolanaExecutionObserver
}
pub(crate) fn select_devnet_profile(
config: &kb_config::AppConfig,
config: &ks_config::AppConfig,
profile_name: &str,
) -> std::result::Result<kb_config::ProfileConfig, std::string::String> {
return kb_pipeline_demo_scenarios::resolve_demo_devnet_profile(
) -> std::result::Result<ks_config::ProfileConfig, std::string::String> {
return ks_pipeline_demo_scenarios::resolve_demo_devnet_profile(
config,
std::option::Option::Some(profile_name),
)
@@ -371,26 +371,26 @@ pub(crate) fn select_devnet_profile(
}
pub(crate) fn execution_cluster_code(
cluster: kb_lib::ExApiExecutionCluster,
cluster: ks_lib::ExApiExecutionCluster,
) -> std::string::String {
return match cluster {
kb_lib::ExApiExecutionCluster::Localnet => "localnet".to_string(),
kb_lib::ExApiExecutionCluster::Devnet => "devnet".to_string(),
kb_lib::ExApiExecutionCluster::Testnet => "testnet".to_string(),
kb_lib::ExApiExecutionCluster::Mainnet => "mainnet".to_string(),
ks_lib::ExApiExecutionCluster::Localnet => "localnet".to_string(),
ks_lib::ExApiExecutionCluster::Devnet => "devnet".to_string(),
ks_lib::ExApiExecutionCluster::Testnet => "testnet".to_string(),
ks_lib::ExApiExecutionCluster::Mainnet => "mainnet".to_string(),
};
}
pub(crate) fn confirmation_status_code(
status: kb_lib::ExApiExecutionConfirmationStatus,
status: ks_lib::ExApiExecutionConfirmationStatus,
) -> std::string::String {
return match status {
kb_lib::ExApiExecutionConfirmationStatus::Processed => "processed".to_string(),
kb_lib::ExApiExecutionConfirmationStatus::Confirmed => "confirmed".to_string(),
kb_lib::ExApiExecutionConfirmationStatus::Finalized => "finalized".to_string(),
kb_lib::ExApiExecutionConfirmationStatus::Failed => "failed".to_string(),
kb_lib::ExApiExecutionConfirmationStatus::Expired => "expired".to_string(),
kb_lib::ExApiExecutionConfirmationStatus::TimedOut => "timed_out".to_string(),
ks_lib::ExApiExecutionConfirmationStatus::Processed => "processed".to_string(),
ks_lib::ExApiExecutionConfirmationStatus::Confirmed => "confirmed".to_string(),
ks_lib::ExApiExecutionConfirmationStatus::Finalized => "finalized".to_string(),
ks_lib::ExApiExecutionConfirmationStatus::Failed => "failed".to_string(),
ks_lib::ExApiExecutionConfirmationStatus::Expired => "expired".to_string(),
ks_lib::ExApiExecutionConfirmationStatus::TimedOut => "timed_out".to_string(),
};
}
@@ -404,7 +404,7 @@ pub(crate) async fn demo_execution_devnet_prepare_profile(
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
let readiness =
match kb_pipeline_demo_scenarios::prepare_demo_devnet_profile_store(&profile).await {
match ks_pipeline_demo_scenarios::prepare_demo_devnet_profile_store(&profile).await {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => {
return std::result::Result::Err(error.to_string());
@@ -433,11 +433,11 @@ pub(crate) fn demo_execution_solana_core_options(
pub(crate) fn demo_execution_solana_core_generate_recipient()
-> std::result::Result<crate::DemoExecutionSolanaCoreGeneratedRecipientPayload, std::string::String>
{
let alias = match kb_wallet::WalletAlias::parse("demo-devnet-recipient") {
let alias = match ks_wallet::WalletAlias::parse("demo-devnet-recipient") {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
};
let wallet = kb_wallet::TemporaryWallet::generate(alias);
let wallet = ks_wallet::TemporaryWallet::generate(alias);
return std::result::Result::Ok(crate::DemoExecutionSolanaCoreGeneratedRecipientPayload {
public_key: wallet.public_key(),
});
@@ -469,7 +469,7 @@ pub(crate) async fn demo_execution_solana_core_execute(
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
let http_pool = match kb_onchain_transport::HttpEndpointPool::from_profile(&profile) {
let http_pool = match ks_onchain_transport::HttpEndpointPool::from_profile(&profile) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
};
@@ -481,9 +481,9 @@ pub(crate) async fn demo_execution_solana_core_execute(
if let std::result::Result::Err(error) = initialize_result {
return std::result::Result::Err(error.to_string());
}
let mut pipeline_request = kb_pipeline_demo_scenarios::DevnetSystemTransferRequest::new(
let mut pipeline_request = ks_pipeline_demo_scenarios::DevnetSystemTransferRequest::new(
format!("demo-execution-{}", chrono::Utc::now().timestamp_micros()),
kb_lib::MdPubkey(request.recipient.trim().to_string()),
ks_lib::MdPubkey(request.recipient.trim().to_string()),
request.lamports,
);
pipeline_request.airdrop_lamports = request.airdrop_lamports;
@@ -492,15 +492,15 @@ pub(crate) async fn demo_execution_solana_core_execute(
pipeline_request.post_validation_max_retries = 20;
pipeline_request.force_post_validation_replay = request.force_post_validation_replay;
pipeline_request.materialize_after_decode = request.materialize_after_decode;
let decoders: std::vec::Vec<std::sync::Arc<dyn kb_lib::DcApiInstructionDecoder>> =
std::vec![std::sync::Arc::new(kb_lib::DcSolanaCoreDecoder)];
let materializers: std::vec::Vec<std::sync::Arc<dyn kb_lib::MtApiEventMaterializer>> =
let decoders: std::vec::Vec<std::sync::Arc<dyn ks_lib::DcApiInstructionDecoder>> =
std::vec![std::sync::Arc::new(ks_lib::DcSolanaCoreDecoder)];
let materializers: std::vec::Vec<std::sync::Arc<dyn ks_lib::MtApiEventMaterializer>> =
if request.materialize_after_decode {
std::vec![
std::sync::Arc::new(kb_lib::MtAdminMaterializer),
std::sync::Arc::new(kb_lib::MtComplianceAuditMaterializer,),
std::sync::Arc::new(kb_lib::MtLifecycleMaterializer),
std::sync::Arc::new(kb_lib::MtStakingMaterializer),
std::sync::Arc::new(ks_lib::MtAdminMaterializer),
std::sync::Arc::new(ks_lib::MtComplianceAuditMaterializer,),
std::sync::Arc::new(ks_lib::MtLifecycleMaterializer),
std::sync::Arc::new(ks_lib::MtStakingMaterializer),
]
} else {
std::vec::Vec::new()
@@ -510,7 +510,7 @@ pub(crate) async fn demo_execution_solana_core_execute(
cancel_requested: state.demo_execution_solana_core_cancel_requested(),
};
let workspace_root = crate::workspace_root_dir();
let summary = match kb_pipeline_demo_scenarios::execute_devnet_system_transfer(
let summary = match ks_pipeline_demo_scenarios::execute_devnet_system_transfer(
&http_pool,
&store,
&profile,
@@ -554,7 +554,7 @@ pub(crate) async fn demo_execution_spl_memo_execute(
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
let http_pool = match kb_onchain_transport::HttpEndpointPool::from_profile(&profile) {
let http_pool = match ks_onchain_transport::HttpEndpointPool::from_profile(&profile) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
};
@@ -565,7 +565,7 @@ pub(crate) async fn demo_execution_spl_memo_execute(
if let std::result::Result::Err(error) = store.initialize_store_schema().await {
return std::result::Result::Err(error.to_string());
}
let mut pipeline_request = kb_pipeline_demo_scenarios::DevnetMemoExecutionRequest::new(
let mut pipeline_request = ks_pipeline_demo_scenarios::DevnetMemoExecutionRequest::new(
format!("demo-memo-execution-{}", chrono::Utc::now().timestamp_micros()),
request.message,
);
@@ -574,16 +574,16 @@ pub(crate) async fn demo_execution_spl_memo_execute(
pipeline_request.operator_confirmed = request.operator_confirmed;
pipeline_request.post_validation_max_retries = 20;
pipeline_request.force_post_validation_replay = request.force_post_validation_replay;
let decoders: std::vec::Vec<std::sync::Arc<dyn kb_lib::DcApiInstructionDecoder>> =
std::vec![std::sync::Arc::new(kb_lib::DcSplMemoDecoder)];
let materializers: std::vec::Vec<std::sync::Arc<dyn kb_lib::MtApiEventMaterializer>> =
std::vec![std::sync::Arc::new(kb_lib::MtTransactionAnnotationMaterializer,)];
let decoders: std::vec::Vec<std::sync::Arc<dyn ks_lib::DcApiInstructionDecoder>> =
std::vec![std::sync::Arc::new(ks_lib::DcSplMemoDecoder)];
let materializers: std::vec::Vec<std::sync::Arc<dyn ks_lib::MtApiEventMaterializer>> =
std::vec![std::sync::Arc::new(ks_lib::MtTransactionAnnotationMaterializer,)];
let observer = crate::DemoExecutionSolanaCoreObserver {
app_handle,
cancel_requested: state.demo_execution_solana_core_cancel_requested(),
};
let workspace_root = crate::workspace_root_dir();
let summary = match kb_pipeline_demo_scenarios::execute_devnet_memo(
let summary = match ks_pipeline_demo_scenarios::execute_devnet_memo(
&http_pool,
&store,
&profile,
@@ -616,7 +616,7 @@ pub(crate) fn demo_execution_solana_core_cancel(state: tauri::State<'_, crate::A
}
fn devnet_profile_options(
config: &kb_config::AppConfig,
config: &ks_config::AppConfig,
) -> std::vec::Vec<crate::DemoExecutionSolanaCoreProfileOption> {
let mut output = std::vec::Vec::new();
for profile in &config.profiles {
@@ -639,7 +639,7 @@ fn devnet_profile_options(
}
fn summary_payload(
summary: kb_pipeline_demo_scenarios::DevnetSystemTransferSummary,
summary: ks_pipeline_demo_scenarios::DevnetSystemTransferSummary,
) -> crate::DemoExecutionSolanaCoreSummaryPayload {
let plan_json = crate::pretty_json(&summary.plan);
let simulation_json = crate::pretty_json(&summary.simulation);
@@ -720,7 +720,7 @@ fn summary_payload(
}
fn memo_summary_payload(
summary: kb_pipeline_demo_scenarios::DevnetMemoExecutionSummary,
summary: ks_pipeline_demo_scenarios::DevnetMemoExecutionSummary,
) -> crate::DemoExecutionMemoSummaryPayload {
let plan_json = crate::pretty_json(&summary.plan);
let simulation_json = crate::pretty_json(&summary.simulation);
@@ -851,7 +851,7 @@ mod tests {
#[test]
fn example_config_exposes_one_devnet_execution_profile() {
let config =
match kb_config::parse_config_json(include_str!("../../config/example.config.json")) {
match ks_config::parse_config_json(include_str!("../../config/example.config.json")) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => panic!("example config parse failed: {error}"),
};
@@ -865,7 +865,7 @@ mod tests {
#[test]
fn profile_selection_rejects_mainnet_profiles() {
let config =
match kb_config::parse_config_json(include_str!("../../config/example.config.json")) {
match ks_config::parse_config_json(include_str!("../../config/example.config.json")) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => panic!("example config parse failed: {error}"),
};

18
kb-app-demo-desktop/src/demo_execution_spl.rs
View File

@@ -1,5 +1,5 @@
// file: kb-app-demo-desktop/src/demo_execution_spl.rs
// version: 5
// version: 6
//! Dedicated Tauri window for bounded SPL execution on Devnet.
@@ -30,32 +30,32 @@ pub(crate) struct DevnetSplValidationScenarioPayload {
/// Returns the complete ordered Devnet SPL validation inventory for milestone 0.4.6.
pub(crate) fn demo_execution_spl_validation_scenarios()
-> std::vec::Vec<crate::DevnetSplValidationScenarioPayload> {
return kb_pipeline_demo_scenarios::devnet_spl_validation_scenarios()
return ks_pipeline_demo_scenarios::devnet_spl_validation_scenarios()
.into_iter()
.map(|scenario| {
return crate::DevnetSplValidationScenarioPayload {
id: scenario.id,
label: scenario.label,
family: match scenario.family {
kb_pipeline_demo_scenarios::DevnetSplValidationFamily::Token2022Public => {
ks_pipeline_demo_scenarios::DevnetSplValidationFamily::Token2022Public => {
"token_2022_public".to_string()
},
kb_pipeline_demo_scenarios::DevnetSplValidationFamily::ElGamalRegistry => {
ks_pipeline_demo_scenarios::DevnetSplValidationFamily::ElGamalRegistry => {
"elgamal_registry".to_string()
},
kb_pipeline_demo_scenarios::DevnetSplValidationFamily::Token2022Confidential => {
ks_pipeline_demo_scenarios::DevnetSplValidationFamily::Token2022Confidential => {
"token_2022_confidential".to_string()
},
},
operation_code: scenario.operation_code,
implementation_status: match scenario.implementation_status {
kb_pipeline_demo_scenarios::DevnetSplValidationImplementationStatus::Executable => {
ks_pipeline_demo_scenarios::DevnetSplValidationImplementationStatus::Executable => {
"executable".to_string()
},
kb_pipeline_demo_scenarios::DevnetSplValidationImplementationStatus::BackendReady => {
ks_pipeline_demo_scenarios::DevnetSplValidationImplementationStatus::BackendReady => {
"backend_ready".to_string()
},
kb_pipeline_demo_scenarios::DevnetSplValidationImplementationStatus::ProofFixtureRequired => {
ks_pipeline_demo_scenarios::DevnetSplValidationImplementationStatus::ProofFixtureRequired => {
"proof_fixture_required".to_string()
},
},
@@ -75,7 +75,7 @@ mod tests {
profile_name: "local_devnet".to_string(),
cluster: "devnet".to_string(),
genesis_hash: "EtWTRABZaYq6iMfeYKouRu166VU2xqa1".to_string(),
wallet_public_key: kb_program_ids::SYSTEM_PROGRAM_ID.to_string(),
wallet_public_key: ks_program_ids::SYSTEM_PROGRAM_ID.to_string(),
balance_lamports: u64::MAX.to_string(),
fee_lamports: std::option::Option::Some(u64::MAX.to_string()),
simulation_success: true,

22
kb-app-demo-desktop/src/demo_http.rs
View File

@@ -1,5 +1,5 @@
// file: kb-app-demo-desktop/src/demo_http.rs
// version: 13
// version: 14
//! HTTP JSON-RPC demo commands.
@@ -142,13 +142,13 @@ pub(crate) async fn demo_http_execute_request(
std::result::Result::Ok(text) => text,
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
};
let method_class = kb_onchain_transport::HttpClient::classify_method(&method);
let method_class = ks_onchain_transport::HttpClient::classify_method(&method);
return std::result::Result::Ok(crate::DemoHttpExecutionPayload {
endpoint_name: selected_client.endpoint_name().to_string(),
provider: selected_client.provider().to_string(),
endpoint_url: selected_client.endpoint_url().to_string(),
role,
request_kind: kb_onchain_transport::request_kind_from_method(&method),
request_kind: ks_onchain_transport::request_kind_from_method(&method),
method,
method_class: method_class_to_string(method_class).to_string(),
response_json,
@@ -157,7 +157,7 @@ pub(crate) async fn demo_http_execute_request(
pub(crate) fn demo_http_list_pool_clients(
state: tauri::State<'_, crate::AppState>,
) -> std::vec::Vec<kb_onchain_transport::HttpPoolClientSnapshot> {
) -> std::vec::Vec<ks_onchain_transport::HttpPoolClientSnapshot> {
return state.http_pool().snapshot();
}
@@ -171,7 +171,7 @@ pub(crate) fn demo_http_options(
}
fn build_http_role_options(
snapshots: std::vec::Vec<kb_onchain_transport::HttpPoolClientSnapshot>,
snapshots: std::vec::Vec<ks_onchain_transport::HttpPoolClientSnapshot>,
) -> std::vec::Vec<crate::DemoHttpRoleOption> {
let mut roles = std::collections::BTreeMap::<
std::string::String,
@@ -256,7 +256,7 @@ fn build_http_method_options() -> std::vec::Vec<crate::DemoHttpMethodOption> {
for (method, label, requires_first_arg, supports_config_json) in methods {
options.push(crate::DemoHttpMethodOption {
method: method.to_string(),
request_kind: kb_onchain_transport::request_kind_from_method(method),
request_kind: ks_onchain_transport::request_kind_from_method(method),
label: label.to_string(),
requires_first_arg,
supports_config_json,
@@ -367,11 +367,11 @@ fn parse_optional_params_json(
return std::result::Result::Ok(std::option::Option::Some(array));
}
fn method_class_to_string(method_class: kb_onchain_transport::HttpMethodClass) -> &'static str {
fn method_class_to_string(method_class: ks_onchain_transport::HttpMethodClass) -> &'static str {
return match method_class {
kb_onchain_transport::HttpMethodClass::GeneralRpc => "GeneralRpc",
kb_onchain_transport::HttpMethodClass::SendTransaction => "SendTransaction",
kb_onchain_transport::HttpMethodClass::HeavyRead => "HeavyRead",
ks_onchain_transport::HttpMethodClass::GeneralRpc => "GeneralRpc",
ks_onchain_transport::HttpMethodClass::SendTransaction => "SendTransaction",
ks_onchain_transport::HttpMethodClass::HeavyRead => "HeavyRead",
};
}
@@ -407,7 +407,7 @@ mod tests {
assert!(names.insert(option.method.as_str()));
assert_eq!(
option.request_kind,
kb_onchain_transport::request_kind_from_method(option.method.as_str())
ks_onchain_transport::request_kind_from_method(option.method.as_str())
);
}
assert!(!options.is_empty());

60
kb-app-demo-desktop/src/demo_spl_ata.rs
View File

@@ -1,5 +1,5 @@
// file: kb-app-demo-desktop/src/demo_spl_ata.rs
// version: 12
// version: 13
//! Thin Tauri adapter for ATA execution, derivation and lifecycle journal reads.
@@ -228,15 +228,15 @@ pub(crate) async fn demo_execution_spl_ata_execute(
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
let wallet_owner = kb_lib::MdPubkey(request.wallet_owner.trim().to_string());
let mint = kb_lib::MdPubkey(request.mint.trim().to_string());
let wallet_owner = ks_lib::MdPubkey(request.wallet_owner.trim().to_string());
let mint = ks_lib::MdPubkey(request.mint.trim().to_string());
let operation = match request.mode.as_str() {
"create" => kb_lib::ExSplAssociatedTokenAccountOperation::Create {
"create" => ks_lib::ExSplAssociatedTokenAccountOperation::Create {
wallet_owner,
mint,
token_program,
},
"create_idempotent" => kb_lib::ExSplAssociatedTokenAccountOperation::CreateIdempotent {
"create_idempotent" => ks_lib::ExSplAssociatedTokenAccountOperation::CreateIdempotent {
wallet_owner,
mint,
token_program,
@@ -248,7 +248,7 @@ pub(crate) async fn demo_execution_spl_ata_execute(
},
};
let mut pipeline_request =
kb_pipeline_demo_scenarios::DevnetSplAssociatedTokenAccountExecutionRequest::new(
ks_pipeline_demo_scenarios::DevnetSplAssociatedTokenAccountExecutionRequest::new(
format!("demo-spl-ata-execution-{}", chrono::Utc::now().timestamp_micros()),
operation,
);
@@ -256,7 +256,7 @@ pub(crate) async fn demo_execution_spl_ata_execute(
pipeline_request.operator_confirmed = request.operator_confirmed;
pipeline_request.post_validation_max_retries = 20;
pipeline_request.force_post_validation_replay = request.force_post_validation_replay;
let http_pool = match kb_onchain_transport::HttpEndpointPool::from_profile(&profile) {
let http_pool = match ks_onchain_transport::HttpEndpointPool::from_profile(&profile) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
};
@@ -267,19 +267,19 @@ pub(crate) async fn demo_execution_spl_ata_execute(
if let std::result::Result::Err(error) = store.initialize_store_schema().await {
return std::result::Result::Err(error.to_string());
}
let decoders: std::vec::Vec<std::sync::Arc<dyn kb_lib::DcApiInstructionDecoder>> = std::vec![
std::sync::Arc::new(kb_lib::DcSplAssociatedTokenAccountDecoder),
std::sync::Arc::new(kb_lib::DcSplTokenDecoder),
let decoders: std::vec::Vec<std::sync::Arc<dyn ks_lib::DcApiInstructionDecoder>> = std::vec![
std::sync::Arc::new(ks_lib::DcSplAssociatedTokenAccountDecoder),
std::sync::Arc::new(ks_lib::DcSplTokenDecoder),
];
let materializers: std::vec::Vec<std::sync::Arc<dyn kb_lib::MtApiEventMaterializer>> = std::vec![
std::sync::Arc::new(kb_lib::MtTokenAccountsMaterializer),
std::sync::Arc::new(kb_lib::MtRiskMaterializer),
let materializers: std::vec::Vec<std::sync::Arc<dyn ks_lib::MtApiEventMaterializer>> = std::vec![
std::sync::Arc::new(ks_lib::MtTokenAccountsMaterializer),
std::sync::Arc::new(ks_lib::MtRiskMaterializer),
];
let observer = crate::DemoExecutionSolanaCoreObserver {
app_handle,
cancel_requested: state.demo_execution_solana_core_cancel_requested(),
};
let summary = match kb_pipeline_demo_scenarios::execute_devnet_spl_associated_token_account(
let summary = match ks_pipeline_demo_scenarios::execute_devnet_spl_associated_token_account(
&http_pool,
&store,
&profile,
@@ -314,7 +314,7 @@ pub(crate) async fn demo_spl_ata_journal(
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
};
let filter = match kb_store::MaterializedEventFilter::new(
let filter = match ks_store::MaterializedEventFilter::new(
std::option::Option::Some("materializer.token.accounts".to_string()),
std::option::Option::None,
request.signature_contains.clone(),
@@ -323,7 +323,7 @@ pub(crate) async fn demo_spl_ata_journal(
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
};
let rows = match kb_store::DecodePipelineStore::list_materialized_events(&store, &filter).await
let rows = match ks_store::DecodePipelineStore::list_materialized_events(&store, &filter).await
{
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
@@ -344,19 +344,19 @@ pub(crate) async fn demo_spl_ata_journal(
}
async fn load_profile_wallet(
profile: &kb_config::ProfileConfig,
) -> std::result::Result<kb_wallet::TemporaryWallet, std::string::String> {
profile: &ks_config::ProfileConfig,
) -> std::result::Result<ks_wallet::TemporaryWallet, std::string::String> {
let configured = std::path::PathBuf::from(profile.wallet.wallet_dir.as_str());
let directory = if configured.is_absolute() {
configured
} else {
crate::workspace_root_dir().join(configured)
};
let store = match kb_wallet::TemporaryWalletStore::new(directory) {
let store = match ks_wallet::TemporaryWalletStore::new(directory) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
};
let alias = match kb_wallet::WalletAlias::parse(profile.wallet.temporary_wallet_alias.clone()) {
let alias = match ks_wallet::WalletAlias::parse(profile.wallet.temporary_wallet_alias.clone()) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
};
@@ -368,10 +368,10 @@ async fn load_profile_wallet(
fn parse_token_program(
value: &str,
) -> std::result::Result<kb_lib::ExSplAssociatedTokenProgram, std::string::String> {
) -> std::result::Result<ks_lib::ExSplAssociatedTokenProgram, std::string::String> {
return match value.trim() {
"classic" => std::result::Result::Ok(kb_lib::ExSplAssociatedTokenProgram::Classic),
"token_2022" => std::result::Result::Ok(kb_lib::ExSplAssociatedTokenProgram::Token2022),
"classic" => std::result::Result::Ok(ks_lib::ExSplAssociatedTokenProgram::Classic),
"token_2022" => std::result::Result::Ok(ks_lib::ExSplAssociatedTokenProgram::Token2022),
_ => std::result::Result::Err("Token Program must be classic or token_2022".to_string()),
};
}
@@ -410,7 +410,7 @@ fn derive_ata(
}
fn summary_payload(
summary: kb_pipeline_demo_scenarios::DevnetSplAssociatedTokenAccountExecutionSummary,
summary: ks_pipeline_demo_scenarios::DevnetSplAssociatedTokenAccountExecutionSummary,
) -> crate::DemoExecutionSplAtaSummaryPayload {
let (associated_token_account, token_program_id) = match summary.plan.instructions.first() {
std::option::Option::Some(instruction) => {
@@ -522,10 +522,10 @@ fn summary_payload(
balance_lamports: summary.balance_lamports.to_string(),
fee_lamports: summary.fee.fee_lamports.map(|value| return value.to_string()),
readiness_status: match summary.stateful_readiness.status {
kb_pipeline::SplAssociatedTokenAccountStatefulReadinessStatus::Ready => {
ks_pipeline::SplAssociatedTokenAccountStatefulReadinessStatus::Ready => {
"ready".to_string()
},
kb_pipeline::SplAssociatedTokenAccountStatefulReadinessStatus::Blocked => {
ks_pipeline::SplAssociatedTokenAccountStatefulReadinessStatus::Blocked => {
"blocked".to_string()
},
},
@@ -558,7 +558,7 @@ fn journal_matches(payload: &serde_json::Value, request: &crate::DemoSplAtaJourn
return true;
}
fn journal_row(row: kb_store::MaterializedEventQueryRow) -> crate::DemoSplAtaJournalRow {
fn journal_row(row: ks_store::MaterializedEventQueryRow) -> crate::DemoSplAtaJournalRow {
let text = |key: &str| {
return row
.payload_json
@@ -585,11 +585,11 @@ fn journal_row(row: kb_store::MaterializedEventQueryRow) -> crate::DemoSplAtaJou
mod tests {
#[test]
fn classic_and_token_2022_derivations_are_distinct_and_canonical() {
let wallet = kb_program_ids::SYSTEM_PROGRAM_ID;
let wallet = ks_program_ids::SYSTEM_PROGRAM_ID;
let mint = "So11111111111111111111111111111111111111112";
let classic = super::derive_ata(wallet, mint, kb_program_ids::SPL_TOKEN_PROGRAM_ID)
let classic = super::derive_ata(wallet, mint, ks_program_ids::SPL_TOKEN_PROGRAM_ID)
.unwrap_or_else(|error| panic!("classic derivation failed: {error}"));
let token_2022 = super::derive_ata(wallet, mint, kb_program_ids::SPL_TOKEN_2022_PROGRAM_ID)
let token_2022 = super::derive_ata(wallet, mint, ks_program_ids::SPL_TOKEN_2022_PROGRAM_ID)
.unwrap_or_else(|error| panic!("Token-2022 derivation failed: {error}"));
assert_eq!(classic, "aqxoAhCwpy3oB1BpNw9hL1HdLYLgPpbPjzxDrrQj3Fs");
assert_eq!(token_2022, "2sZUUBGq1i6aE47ZoxCaCW89jmYm2EXLPPmNMgMDXHMS");

58
kb-app-demo-desktop/src/demo_spl_token.rs
View File

@@ -1,5 +1,5 @@
// file: kb-app-demo-desktop/src/demo_spl_token.rs
// version: 9
// version: 10
//! Thin Tauri adapter for classic SPL Token execution and materialized journals.
@@ -179,7 +179,7 @@ pub(crate) async fn demo_execution_spl_token_execute(
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
let http_pool = match kb_onchain_transport::HttpEndpointPool::from_profile(&profile) {
let http_pool = match ks_onchain_transport::HttpEndpointPool::from_profile(&profile) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
};
@@ -191,20 +191,20 @@ pub(crate) async fn demo_execution_spl_token_execute(
return std::result::Result::Err(error.to_string());
}
let amount_raw = request.amount_raw.trim().to_string();
let operation = kb_lib::ExSplClassicTokenOperation::Instruction {
value: kb_lib::ExSplClassicTokenSingleOperation::TransferChecked {
source: kb_lib::MdPubkey(request.source.trim().to_string()),
mint: kb_lib::MdPubkey(request.mint.trim().to_string()),
destination: kb_lib::MdPubkey(request.destination.trim().to_string()),
authority: kb_lib::ExSplClassicTokenAuthority {
authority: kb_lib::MdPubkey(request.authority.trim().to_string()),
let operation = ks_lib::ExSplClassicTokenOperation::Instruction {
value: ks_lib::ExSplClassicTokenSingleOperation::TransferChecked {
source: ks_lib::MdPubkey(request.source.trim().to_string()),
mint: ks_lib::MdPubkey(request.mint.trim().to_string()),
destination: ks_lib::MdPubkey(request.destination.trim().to_string()),
authority: ks_lib::ExSplClassicTokenAuthority {
authority: ks_lib::MdPubkey(request.authority.trim().to_string()),
multisig_signers: std::vec::Vec::new(),
},
amount: kb_lib::ExSplClassicTokenAmount(amount_raw.clone()),
amount: ks_lib::ExSplClassicTokenAmount(amount_raw.clone()),
decimals: request.decimals,
},
};
let mut pipeline_request = kb_pipeline_demo_scenarios::DevnetSplTokenExecutionRequest::new(
let mut pipeline_request = ks_pipeline_demo_scenarios::DevnetSplTokenExecutionRequest::new(
format!("demo-spl-token-execution-{}", chrono::Utc::now().timestamp_micros()),
operation,
);
@@ -212,19 +212,19 @@ pub(crate) async fn demo_execution_spl_token_execute(
pipeline_request.operator_confirmed = request.operator_confirmed;
pipeline_request.post_validation_max_retries = 20;
pipeline_request.force_post_validation_replay = request.force_post_validation_replay;
let decoders: std::vec::Vec<std::sync::Arc<dyn kb_lib::DcApiInstructionDecoder>> =
std::vec![std::sync::Arc::new(kb_lib::DcSplTokenDecoder)];
let materializers: std::vec::Vec<std::sync::Arc<dyn kb_lib::MtApiEventMaterializer>> = std::vec![
std::sync::Arc::new(kb_lib::MtTokenAccountsMaterializer),
std::sync::Arc::new(kb_lib::MtAdminMaterializer),
std::sync::Arc::new(kb_lib::MtRiskMaterializer),
let decoders: std::vec::Vec<std::sync::Arc<dyn ks_lib::DcApiInstructionDecoder>> =
std::vec![std::sync::Arc::new(ks_lib::DcSplTokenDecoder)];
let materializers: std::vec::Vec<std::sync::Arc<dyn ks_lib::MtApiEventMaterializer>> = std::vec![
std::sync::Arc::new(ks_lib::MtTokenAccountsMaterializer),
std::sync::Arc::new(ks_lib::MtAdminMaterializer),
std::sync::Arc::new(ks_lib::MtRiskMaterializer),
];
let observer = crate::DemoExecutionSolanaCoreObserver {
app_handle,
cancel_requested: state.demo_execution_solana_core_cancel_requested(),
};
let workspace_root = crate::workspace_root_dir();
let summary = match kb_pipeline_demo_scenarios::execute_devnet_spl_token(
let summary = match ks_pipeline_demo_scenarios::execute_devnet_spl_token(
&http_pool,
&store,
&profile,
@@ -266,11 +266,11 @@ pub(crate) async fn demo_spl_token_journal(
let needs_payload_filter =
validated.mint.is_some() || validated.account.is_some() || validated.operation.is_some();
let query_limit = if needs_payload_filter {
kb_store::MAX_MATERIALIZED_EVENT_QUERY_ROWS
ks_store::MAX_MATERIALIZED_EVENT_QUERY_ROWS
} else {
validated.limit
};
let filter = match kb_store::MaterializedEventFilter::new(
let filter = match ks_store::MaterializedEventFilter::new(
std::option::Option::None,
validated.family.clone(),
validated.signature_contains.clone(),
@@ -279,7 +279,7 @@ pub(crate) async fn demo_spl_token_journal(
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
};
let rows = match kb_store::DecodePipelineStore::list_materialized_events(&store, &filter).await
let rows = match ks_store::DecodePipelineStore::list_materialized_events(&store, &filter).await
{
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
@@ -299,7 +299,7 @@ pub(crate) async fn demo_spl_token_journal(
}
fn summary_payload(
summary: kb_pipeline_demo_scenarios::DevnetSplTokenExecutionSummary,
summary: ks_pipeline_demo_scenarios::DevnetSplTokenExecutionSummary,
amount_raw: std::string::String,
decimals: u8,
) -> crate::DemoExecutionSplTokenSummaryPayload {
@@ -370,8 +370,8 @@ fn summary_payload(
amount_raw,
decimals,
readiness_status: match summary.stateful_readiness.status {
kb_pipeline::SplTokenStatefulReadinessStatus::Ready => "ready".to_string(),
kb_pipeline::SplTokenStatefulReadinessStatus::Blocked => "blocked".to_string(),
ks_pipeline::SplTokenStatefulReadinessStatus::Ready => "ready".to_string(),
ks_pipeline::SplTokenStatefulReadinessStatus::Blocked => "blocked".to_string(),
},
simulation_success: summary.simulation.success,
simulation_error: summary.simulation.error,
@@ -389,7 +389,7 @@ fn summary_payload(
};
}
fn replay_diagnostics(summary: &kb_pipeline::DecodeReplaySummary) -> serde_json::Value {
fn replay_diagnostics(summary: &ks_pipeline::DecodeReplaySummary) -> serde_json::Value {
return serde_json::json!({
"campaignId": summary.campaign_id,
"selected": summary.selected,
@@ -415,10 +415,10 @@ fn replay_diagnostics(summary: &kb_pipeline::DecodeReplaySummary) -> serde_json:
fn validate_journal_request(
request: crate::DemoSplTokenJournalRequest,
) -> std::result::Result<crate::DemoSplTokenJournalRequest, std::string::String> {
if request.limit == 0 || request.limit > kb_store::MAX_MATERIALIZED_EVENT_QUERY_ROWS {
if request.limit == 0 || request.limit > ks_store::MAX_MATERIALIZED_EVENT_QUERY_ROWS {
return std::result::Result::Err(format!(
"journal limit must be between 1 and {}",
kb_store::MAX_MATERIALIZED_EVENT_QUERY_ROWS
ks_store::MAX_MATERIALIZED_EVENT_QUERY_ROWS
));
}
if request.profile_name.trim().is_empty() {
@@ -499,7 +499,7 @@ fn payload_matches(
return true;
}
fn journal_row(row: kb_store::MaterializedEventQueryRow) -> DemoSplTokenJournalRow {
fn journal_row(row: ks_store::MaterializedEventQueryRow) -> DemoSplTokenJournalRow {
let operation = row
.payload_json
.get("operation")
@@ -605,7 +605,7 @@ mod tests {
payload.get("amountRaw").and_then(serde_json::Value::as_str),
std::option::Option::Some("18446744073709551615")
);
let row = super::journal_row(kb_store::MaterializedEventQueryRow {
let row = super::journal_row(ks_store::MaterializedEventQueryRow {
processor_name: "materializer.token.accounts".to_string(),
processor_version: "0.4.4".to_string(),
input_key: "input".to_string(),

102
kb-app-demo-desktop/src/demo_spl_token_2022.rs
View File

@@ -1,5 +1,5 @@
// file: kb-app-demo-desktop/src/demo_spl_token_2022.rs
// version: 12
// version: 13
//! Thin Tauri adapter for independent public Token-2022 Devnet validation scenarios.
@@ -157,7 +157,7 @@ pub(crate) async fn demo_execution_spl_token_2022_execute(
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
let http_pool = match kb_onchain_transport::HttpEndpointPool::from_profile(&profile) {
let http_pool = match ks_onchain_transport::HttpEndpointPool::from_profile(&profile) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
};
@@ -173,7 +173,7 @@ pub(crate) async fn demo_execution_spl_token_2022_execute(
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
let operation_code = operation.operation_code().to_string();
let mut pipeline_request = kb_pipeline_demo_scenarios::DevnetSplToken2022ExecutionRequest::new(
let mut pipeline_request = ks_pipeline_demo_scenarios::DevnetSplToken2022ExecutionRequest::new(
format!("demo-spl-token-2022-execution-{}", chrono::Utc::now().timestamp_micros()),
operation,
);
@@ -181,21 +181,21 @@ pub(crate) async fn demo_execution_spl_token_2022_execute(
pipeline_request.operator_confirmed = request.operator_confirmed;
pipeline_request.post_validation_max_retries = 20;
pipeline_request.force_post_validation_replay = request.force_post_validation_replay;
let decoders: std::vec::Vec<std::sync::Arc<dyn kb_lib::DcApiInstructionDecoder>> =
std::vec![std::sync::Arc::new(kb_lib::DcSplToken2022Decoder)];
let materializers: std::vec::Vec<std::sync::Arc<dyn kb_lib::MtApiEventMaterializer>> = std::vec![
std::sync::Arc::new(kb_lib::MtTokenAccountsMaterializer),
std::sync::Arc::new(kb_lib::MtAdminMaterializer),
std::sync::Arc::new(kb_lib::MtRiskMaterializer),
std::sync::Arc::new(kb_lib::MtFeesMaterializer),
std::sync::Arc::new(kb_lib::MtComplianceAuditMaterializer),
let decoders: std::vec::Vec<std::sync::Arc<dyn ks_lib::DcApiInstructionDecoder>> =
std::vec![std::sync::Arc::new(ks_lib::DcSplToken2022Decoder)];
let materializers: std::vec::Vec<std::sync::Arc<dyn ks_lib::MtApiEventMaterializer>> = std::vec![
std::sync::Arc::new(ks_lib::MtTokenAccountsMaterializer),
std::sync::Arc::new(ks_lib::MtAdminMaterializer),
std::sync::Arc::new(ks_lib::MtRiskMaterializer),
std::sync::Arc::new(ks_lib::MtFeesMaterializer),
std::sync::Arc::new(ks_lib::MtComplianceAuditMaterializer),
];
let observer = crate::DemoExecutionSolanaCoreObserver {
app_handle,
cancel_requested: state.demo_execution_solana_core_cancel_requested(),
};
let workspace_root = crate::workspace_root_dir();
let summary = match kb_pipeline_demo_scenarios::execute_devnet_spl_token_2022(
let summary = match ks_pipeline_demo_scenarios::execute_devnet_spl_token_2022(
&http_pool,
&store,
&profile,
@@ -321,63 +321,63 @@ pub(crate) fn demo_spl_token_2022_fixture(
fn operation_from_request(
request: &crate::DemoExecutionSplToken2022Request,
) -> std::result::Result<kb_lib::ExSplToken2022Operation, std::string::String> {
let authority = kb_lib::ExSplTokenAuthority {
authority: kb_lib::MdPubkey(request.authority.trim().to_string()),
) -> std::result::Result<ks_lib::ExSplToken2022Operation, std::string::String> {
let authority = ks_lib::ExSplTokenAuthority {
authority: ks_lib::MdPubkey(request.authority.trim().to_string()),
multisig_signers: std::vec::Vec::new(),
};
let freeze_authority = kb_lib::ExSplTokenAuthority {
authority: kb_lib::MdPubkey(request.freeze_authority.trim().to_string()),
let freeze_authority = ks_lib::ExSplTokenAuthority {
authority: ks_lib::MdPubkey(request.freeze_authority.trim().to_string()),
multisig_signers: std::vec::Vec::new(),
};
let value = match request.scenario_id.trim() {
"token_2022_mint_to_checked" => kb_lib::ExSplTokenSingleOperation::MintToChecked {
mint: kb_lib::MdPubkey(request.mint.trim().to_string()),
destination: kb_lib::MdPubkey(request.source.trim().to_string()),
"token_2022_mint_to_checked" => ks_lib::ExSplTokenSingleOperation::MintToChecked {
mint: ks_lib::MdPubkey(request.mint.trim().to_string()),
destination: ks_lib::MdPubkey(request.source.trim().to_string()),
authority,
amount: kb_lib::ExSplTokenAmount(request.amount_raw.trim().to_string()),
amount: ks_lib::ExSplTokenAmount(request.amount_raw.trim().to_string()),
decimals: request.decimals,
},
"token_2022_transfer_checked" => kb_lib::ExSplTokenSingleOperation::TransferChecked {
source: kb_lib::MdPubkey(request.source.trim().to_string()),
mint: kb_lib::MdPubkey(request.mint.trim().to_string()),
destination: kb_lib::MdPubkey(request.destination.trim().to_string()),
"token_2022_transfer_checked" => ks_lib::ExSplTokenSingleOperation::TransferChecked {
source: ks_lib::MdPubkey(request.source.trim().to_string()),
mint: ks_lib::MdPubkey(request.mint.trim().to_string()),
destination: ks_lib::MdPubkey(request.destination.trim().to_string()),
authority,
amount: kb_lib::ExSplTokenAmount(request.amount_raw.trim().to_string()),
amount: ks_lib::ExSplTokenAmount(request.amount_raw.trim().to_string()),
decimals: request.decimals,
},
"token_2022_approve_checked" => kb_lib::ExSplTokenSingleOperation::ApproveChecked {
source: kb_lib::MdPubkey(request.source.trim().to_string()),
mint: kb_lib::MdPubkey(request.mint.trim().to_string()),
delegate: kb_lib::MdPubkey(request.delegate.trim().to_string()),
"token_2022_approve_checked" => ks_lib::ExSplTokenSingleOperation::ApproveChecked {
source: ks_lib::MdPubkey(request.source.trim().to_string()),
mint: ks_lib::MdPubkey(request.mint.trim().to_string()),
delegate: ks_lib::MdPubkey(request.delegate.trim().to_string()),
authority,
amount: kb_lib::ExSplTokenAmount(request.amount_raw.trim().to_string()),
amount: ks_lib::ExSplTokenAmount(request.amount_raw.trim().to_string()),
decimals: request.decimals,
},
"token_2022_revoke" => kb_lib::ExSplTokenSingleOperation::Revoke {
source: kb_lib::MdPubkey(request.source.trim().to_string()),
"token_2022_revoke" => ks_lib::ExSplTokenSingleOperation::Revoke {
source: ks_lib::MdPubkey(request.source.trim().to_string()),
authority,
},
"token_2022_burn_checked" => kb_lib::ExSplTokenSingleOperation::BurnChecked {
source: kb_lib::MdPubkey(request.source.trim().to_string()),
mint: kb_lib::MdPubkey(request.mint.trim().to_string()),
"token_2022_burn_checked" => ks_lib::ExSplTokenSingleOperation::BurnChecked {
source: ks_lib::MdPubkey(request.source.trim().to_string()),
mint: ks_lib::MdPubkey(request.mint.trim().to_string()),
authority,
amount: kb_lib::ExSplTokenAmount(request.amount_raw.trim().to_string()),
amount: ks_lib::ExSplTokenAmount(request.amount_raw.trim().to_string()),
decimals: request.decimals,
},
"token_2022_freeze_account" => kb_lib::ExSplTokenSingleOperation::FreezeAccount {
account: kb_lib::MdPubkey(request.source.trim().to_string()),
mint: kb_lib::MdPubkey(request.mint.trim().to_string()),
"token_2022_freeze_account" => ks_lib::ExSplTokenSingleOperation::FreezeAccount {
account: ks_lib::MdPubkey(request.source.trim().to_string()),
mint: ks_lib::MdPubkey(request.mint.trim().to_string()),
authority: freeze_authority,
},
"token_2022_thaw_account" => kb_lib::ExSplTokenSingleOperation::ThawAccount {
account: kb_lib::MdPubkey(request.source.trim().to_string()),
mint: kb_lib::MdPubkey(request.mint.trim().to_string()),
"token_2022_thaw_account" => ks_lib::ExSplTokenSingleOperation::ThawAccount {
account: ks_lib::MdPubkey(request.source.trim().to_string()),
mint: ks_lib::MdPubkey(request.mint.trim().to_string()),
authority: freeze_authority,
},
"token_2022_close_destination" => kb_lib::ExSplTokenSingleOperation::CloseAccount {
account: kb_lib::MdPubkey(request.source.trim().to_string()),
destination: kb_lib::MdPubkey(request.destination.trim().to_string()),
"token_2022_close_destination" => ks_lib::ExSplTokenSingleOperation::CloseAccount {
account: ks_lib::MdPubkey(request.source.trim().to_string()),
destination: ks_lib::MdPubkey(request.destination.trim().to_string()),
authority,
},
other => {
@@ -386,7 +386,7 @@ fn operation_from_request(
));
},
};
return std::result::Result::Ok(kb_lib::ExSplToken2022Operation::Instruction {
return std::result::Result::Ok(ks_lib::ExSplToken2022Operation::Instruction {
value: std::boxed::Box::new(value),
});
}
@@ -394,7 +394,7 @@ fn operation_from_request(
fn summary_payload(
scenario_id: std::string::String,
operation: std::string::String,
summary: kb_pipeline_demo_scenarios::DevnetSplToken2022ExecutionSummary,
summary: ks_pipeline_demo_scenarios::DevnetSplToken2022ExecutionSummary,
) -> crate::DemoExecutionSplToken2022SummaryPayload {
let plan_json = crate::pretty_json(&summary.plan);
let preflight_json = crate::pretty_json(&summary.stateful_preflight);
@@ -477,7 +477,7 @@ fn parse_fixture(
return values;
}
fn backfill_summary_json(summary: &kb_pipeline::BackfillSummary) -> serde_json::Value {
fn backfill_summary_json(summary: &ks_pipeline::BackfillSummary) -> serde_json::Value {
return serde_json::json!({
"captureSessionId": summary.capture_session_id,
"filterCode": summary.filter_code,
@@ -505,7 +505,7 @@ fn backfill_summary_json(summary: &kb_pipeline::BackfillSummary) -> serde_json::
});
}
fn core_extraction_summary_json(summary: &kb_pipeline::CoreExtractionSummary) -> serde_json::Value {
fn core_extraction_summary_json(summary: &ks_pipeline::CoreExtractionSummary) -> serde_json::Value {
return serde_json::json!({
"processorVersion": summary.processor_version,
"selected": summary.selected,
@@ -522,7 +522,7 @@ fn core_extraction_summary_json(summary: &kb_pipeline::CoreExtractionSummary) ->
});
}
fn decode_replay_summary_json(summary: &kb_pipeline::DecodeReplaySummary) -> serde_json::Value {
fn decode_replay_summary_json(summary: &ks_pipeline::DecodeReplaySummary) -> serde_json::Value {
let processors = summary
.processors
.iter()

28
kb-app-demo-desktop/src/demo_sql_common.rs
View File

@@ -1,5 +1,5 @@
// file: kb-app-demo-desktop/src/demo_sql_common.rs
// version: 12
// version: 13
//! Shared SQL demo helpers and serializable payloads.
@@ -34,12 +34,12 @@ pub(crate) struct DemoSqlTableSnapshot {
pub(crate) latest_created_at: std::option::Option<std::string::String>,
}
/// Builds PostgreSQL options from the active profile without coupling kb-store to kb-config.
/// Builds PostgreSQL options from the active profile without coupling ks-store to ks-config.
pub(crate) fn postgres_store_options_from_profile(
profile: &kb_config::ProfileConfig,
profile: &ks_config::ProfileConfig,
auto_initialize_schema: bool,
) -> kb_core::Result<kb_store::PostgresStoreOptions> {
return kb_store::PostgresStoreOptions::new(
) -> ks_core::Result<ks_store::PostgresStoreOptions> {
return ks_store::PostgresStoreOptions::new(
profile.database.postgres.url.clone(),
profile.database.postgres.max_connections,
profile.database.postgres.connect_timeout_ms,
@@ -49,8 +49,8 @@ pub(crate) fn postgres_store_options_from_profile(
/// Connects to PostgreSQL without reapplying schemas initialized at application startup.
pub(crate) async fn connect_postgres_store(
profile: &kb_config::ProfileConfig,
) -> std::result::Result<kb_store::PostgresStore, std::string::String> {
profile: &ks_config::ProfileConfig,
) -> std::result::Result<ks_store::PostgresStore, std::string::String> {
if !profile.database.enabled {
return std::result::Result::Err(std::string::String::from(
"database configuration is disabled in the active profile",
@@ -62,7 +62,7 @@ pub(crate) async fn connect_postgres_store(
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
};
options.auto_initialize_schema = false;
let store_result = kb_store::PostgresStore::connect(options).await;
let store_result = ks_store::PostgresStore::connect(options).await;
return match store_result {
std::result::Result::Ok(store) => std::result::Result::Ok(store),
std::result::Result::Err(error) => std::result::Result::Err(error.to_string()),
@@ -71,7 +71,7 @@ pub(crate) async fn connect_postgres_store(
/// Converts store table diagnostics to the UI payload shape.
pub(crate) fn table_snapshot_from_pg(
value: &kb_store::PostgresTableDiagnostics,
value: &ks_store::PostgresTableDiagnostics,
) -> crate::DemoSqlTableSnapshot {
let row_count = match &value.statistics {
std::option::Option::Some(statistics) => std::option::Option::Some(statistics.row_count),
@@ -103,7 +103,7 @@ pub(crate) fn table_snapshot_from_pg(
/// Converts many table diagnostics to UI payloads.
pub(crate) fn table_snapshots_from_pg(
values: &[kb_store::PostgresTableDiagnostics],
values: &[ks_store::PostgresTableDiagnostics],
) -> std::vec::Vec<crate::DemoSqlTableSnapshot> {
let mut output = std::vec::Vec::new();
for value in values {
@@ -169,7 +169,7 @@ pub(crate) async fn initialize_postgres_schema_for_startup(
);
}
tracing::debug!(target: crate::TRACING_TARGET, dsn = masked_dsn.as_str(), "start PostgreSQL schema initialization");
let store_result = kb_store::PostgresStore::connect(options).await;
let store_result = ks_store::PostgresStore::connect(options).await;
let store = match store_result {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => {
@@ -218,8 +218,8 @@ pub(crate) fn debug_status<T: std::fmt::Debug>(value: T) -> std::string::String
fn emit_sql_startup_table_report(
splash_window: &tauri::WebviewWindow,
before_tables: &[kb_store::PostgresTableDiagnostics],
after_tables: &[kb_store::PostgresTableDiagnostics],
before_tables: &[ks_store::PostgresTableDiagnostics],
after_tables: &[ks_store::PostgresTableDiagnostics],
) {
let mut created_count = 0_u32;
let mut existing_count = 0_u32;
@@ -268,7 +268,7 @@ fn emit_sql_startup_table_report(
}
fn table_exists_in(
tables: &[kb_store::PostgresTableDiagnostics],
tables: &[ks_store::PostgresTableDiagnostics],
table_name: &str,
) -> std::option::Option<bool> {
for table in tables {

54
kb-app-demo-desktop/src/demo_sql_replay_candidates.rs
View File

@@ -1,11 +1,11 @@
// file: kb-app-demo-desktop/src/demo_sql_replay_candidates.rs
// version: 12
// version: 13
//! Read-only SQL replay candidate browser commands.
use ts_rs::TS; // rust-rules: derive-import
/// One program identifier exposed by the runtime `kb_program_ids` registry.
/// One program identifier exposed by the runtime `ks_program_ids` registry.
#[derive(Clone, Debug, serde::Serialize, TS)]
#[serde(rename_all = "camelCase")]
#[ts(
@@ -33,7 +33,7 @@ pub(crate) struct DemoSqlReplayOptionsPayload {
pub(crate) masked_dsn: std::string::String,
/// Maximum rows accepted by one query.
pub(crate) maximum_limit: u32,
/// Program identifiers enumerable from `kb_program_ids`.
/// Program identifiers enumerable from `ks_program_ids`.
pub(crate) known_programs: std::vec::Vec<crate::DemoSqlReplayKnownProgramOption>,
}
@@ -136,7 +136,7 @@ pub(crate) struct DemoSqlReplayProgramRequest {
export_to = "../frontend/ts/bindings/kb_app_demo_desktop/demo_sql_replay_candidates/DemoSqlReplayProgramRow.ts"
)]
pub(crate) struct DemoSqlReplayProgramRow {
/// Optional stable code from `kb_program_ids`.
/// Optional stable code from `ks_program_ids`.
pub(crate) program_code: std::option::Option<std::string::String>,
/// Program id.
pub(crate) program_id: std::string::String,
@@ -251,8 +251,8 @@ pub(crate) async fn demo_sql_replay_options(
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
};
let mut known_programs =
std::vec::Vec::with_capacity(kb_program_ids::registered_program_ids().len());
for entry in kb_program_ids::registered_program_ids() {
std::vec::Vec::with_capacity(ks_program_ids::registered_program_ids().len());
for entry in ks_program_ids::registered_program_ids() {
known_programs.push(crate::DemoSqlReplayKnownProgramOption {
code: entry.code().to_owned(),
program_id: entry.program_id().to_owned(),
@@ -261,7 +261,7 @@ pub(crate) async fn demo_sql_replay_options(
return std::result::Result::Ok(crate::DemoSqlReplayOptionsPayload {
active_profile_name: profile.name,
masked_dsn: options.masked_dsn(),
maximum_limit: kb_store::MAX_REPLAY_CANDIDATE_ROWS,
maximum_limit: ks_store::MAX_REPLAY_CANDIDATE_ROWS,
known_programs,
});
}
@@ -281,7 +281,7 @@ pub(crate) async fn load_demo_sql_replay_transactions(
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
let filter_result = kb_store::PostgresReplayTransactionFilter::new(
let filter_result = ks_store::PostgresReplayTransactionFilter::new(
request.signature_contains,
request.min_slot,
request.max_slot,
@@ -322,7 +322,7 @@ pub(crate) async fn load_demo_sql_replay_programs(
request: crate::DemoSqlReplayProgramRequest,
) -> std::result::Result<std::vec::Vec<crate::DemoSqlReplayProgramRow>, std::string::String> {
let filter_result =
kb_store::PostgresReplayProgramFilter::new(request.program_id_contains, request.limit);
ks_store::PostgresReplayProgramFilter::new(request.program_id_contains, request.limit);
let filter = match filter_result {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
@@ -355,7 +355,7 @@ pub(crate) async fn load_demo_sql_replay_entities(
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
let filter_result = kb_store::PostgresReplayEntityFilter::new(
let filter_result = ks_store::PostgresReplayEntityFilter::new(
entity_kind,
request.entity_value_contains,
request.limit,
@@ -383,7 +383,7 @@ pub(crate) async fn load_demo_sql_replay_entities(
}
fn transaction_row_from_pg(
row: kb_store::PostgresReplayTransactionCandidate,
row: ks_store::PostgresReplayTransactionCandidate,
) -> crate::DemoSqlReplayTransactionRow {
return crate::DemoSqlReplayTransactionRow {
signature: row.signature,
@@ -404,9 +404,9 @@ fn transaction_row_from_pg(
}
fn program_row_from_pg(
row: kb_store::PostgresReplayProgramSummary,
row: ks_store::PostgresReplayProgramSummary,
) -> crate::DemoSqlReplayProgramRow {
let program_code = kb_program_ids::find_registered_program_id(&row.program_id)
let program_code = ks_program_ids::find_registered_program_id(&row.program_id)
.map(|entry| return entry.code().to_owned());
return crate::DemoSqlReplayProgramRow {
program_code,
@@ -420,7 +420,7 @@ fn program_row_from_pg(
};
}
fn entity_row_from_pg(row: kb_store::PostgresReplayEntitySummary) -> crate::DemoSqlReplayEntityRow {
fn entity_row_from_pg(row: ks_store::PostgresReplayEntitySummary) -> crate::DemoSqlReplayEntityRow {
return crate::DemoSqlReplayEntityRow {
entity_kind: row.entity_kind,
entity_value: row.entity_value,
@@ -480,19 +480,19 @@ async fn available_csv_export_path(
fn program_scope_from_code(
code: &str,
) -> std::result::Result<kb_store::PostgresReplayProgramScope, std::string::String> {
) -> std::result::Result<ks_store::PostgresReplayProgramScope, std::string::String> {
return match code {
"any" => std::result::Result::Ok(kb_store::PostgresReplayProgramScope::Any),
"outer" => std::result::Result::Ok(kb_store::PostgresReplayProgramScope::Outer),
"inner" => std::result::Result::Ok(kb_store::PostgresReplayProgramScope::Inner),
"logs" => std::result::Result::Ok(kb_store::PostgresReplayProgramScope::Logs),
"any" => std::result::Result::Ok(ks_store::PostgresReplayProgramScope::Any),
"outer" => std::result::Result::Ok(ks_store::PostgresReplayProgramScope::Outer),
"inner" => std::result::Result::Ok(ks_store::PostgresReplayProgramScope::Inner),
"logs" => std::result::Result::Ok(ks_store::PostgresReplayProgramScope::Logs),
_ => std::result::Result::Err(format!("unsupported replay program scope: {code}")),
};
}
fn optional_entity_kind_from_code(
code: std::option::Option<&str>,
) -> std::result::Result<std::option::Option<kb_store::PostgresReplayEntityKind>, std::string::String>
) -> std::result::Result<std::option::Option<ks_store::PostgresReplayEntityKind>, std::string::String>
{
return match code {
std::option::Option::Some(value) => {
@@ -510,11 +510,11 @@ fn optional_entity_kind_from_code(
fn entity_kind_from_code(
code: &str,
) -> std::result::Result<kb_store::PostgresReplayEntityKind, std::string::String> {
) -> std::result::Result<ks_store::PostgresReplayEntityKind, std::string::String> {
return match code {
"mint" => std::result::Result::Ok(kb_store::PostgresReplayEntityKind::Mint),
"owner" => std::result::Result::Ok(kb_store::PostgresReplayEntityKind::Owner),
"account_key" => std::result::Result::Ok(kb_store::PostgresReplayEntityKind::AccountKey),
"mint" => std::result::Result::Ok(ks_store::PostgresReplayEntityKind::Mint),
"owner" => std::result::Result::Ok(ks_store::PostgresReplayEntityKind::Owner),
"account_key" => std::result::Result::Ok(ks_store::PostgresReplayEntityKind::AccountKey),
_ => std::result::Result::Err(format!("unsupported replay entity kind: {code}")),
};
}
@@ -524,7 +524,7 @@ mod tests {
#[test]
fn program_scope_parser_accepts_logs() {
let result = super::program_scope_from_code("logs");
assert_eq!(result, std::result::Result::Ok(kb_store::PostgresReplayProgramScope::Logs));
assert_eq!(result, std::result::Result::Ok(ks_store::PostgresReplayProgramScope::Logs));
}
#[test]
@@ -551,8 +551,8 @@ mod tests {
#[test]
fn program_row_exposes_registered_code() {
let row = kb_store::PostgresReplayProgramSummary {
program_id: kb_program_ids::SYSTEM_PROGRAM_ID.to_owned(),
let row = ks_store::PostgresReplayProgramSummary {
program_id: ks_program_ids::SYSTEM_PROGRAM_ID.to_owned(),
transaction_count: 1,
outer_instruction_count: 1,
inner_instruction_count: 0,

122
kb-app-demo-desktop/src/demo_ws.rs
View File

@@ -1,7 +1,7 @@
// file: kb-app-demo-desktop/src/demo_ws.rs
// version: 19
// version: 20
//! Standard Solana WebSocket demo commands backed by `kb_onchain_transport::WsSession`.
//! Standard Solana WebSocket demo commands backed by `ks_onchain_transport::WsSession`.
use tauri::Emitter; // rust-rules: trait-import
use tauri::Manager; // rust-rules: trait-import
@@ -179,7 +179,7 @@ pub(crate) struct DemoWsMessagePayload {
pub(crate) payload_json: std::string::String,
}
/// Connects if needed, then subscribes through `kb_onchain_transport::WsSession`.
/// Connects if needed, then subscribes through `ks_onchain_transport::WsSession`.
pub(crate) async fn demo_ws_connect(
app_handle: tauri::AppHandle,
state: &crate::AppState,
@@ -233,7 +233,7 @@ pub(crate) async fn demo_ws_connect(
endpoint_url: selected_client.endpoint_url().to_string(),
role,
method: method.clone(),
request_kind: kb_onchain_transport::request_kind_from_method(&method),
request_kind: ks_onchain_transport::request_kind_from_method(&method),
response_kind: acknowledgement.response.kind_name().to_string(),
subscription_id: acknowledgement.subscription.remote_subscription_id,
response_json,
@@ -260,7 +260,7 @@ pub(crate) async fn demo_ws_status(
pub(crate) fn demo_ws_list_pool_clients(
state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<
std::vec::Vec<kb_onchain_transport::WsPoolClientSnapshot>,
std::vec::Vec<ks_onchain_transport::WsPoolClientSnapshot>,
std::string::String,
> {
let pool = match state.demo_ws_pool() {
@@ -384,15 +384,15 @@ impl DemoWsUiRateLimiter {
async fn ensure_session(
app_handle: &tauri::AppHandle,
state: &crate::AppState,
selected_client: kb_onchain_transport::WsClient,
) -> std::result::Result<std::sync::Arc<kb_onchain_transport::WsSession>, std::string::String> {
selected_client: ks_onchain_transport::WsClient,
) -> std::result::Result<std::sync::Arc<ks_onchain_transport::WsSession>, std::string::String> {
let existing = {
let guard = state.demo_ws_session().lock().await;
guard.clone()
};
if let std::option::Option::Some(session) = existing {
let snapshot = session.snapshot().await;
if snapshot.state != kb_onchain_transport::WsSessionState::Disconnected {
if snapshot.state != ks_onchain_transport::WsSessionState::Disconnected {
if snapshot.endpoint_url != selected_client.endpoint_url() {
return std::result::Result::Err(format!(
"demo WebSocket session already uses endpoint '{}'; disconnect before selecting '{}'",
@@ -404,7 +404,7 @@ async fn ensure_session(
}
}
let reconnect_policy = if selected_client.endpoint_config().auto_reconnect {
match kb_onchain_transport::WsReconnectPolicy::bounded(
match ks_onchain_transport::WsReconnectPolicy::bounded(
DEMO_WS_RECONNECT_ATTEMPTS,
DEMO_WS_RECONNECT_INITIAL_DELAY_MS,
DEMO_WS_RECONNECT_MAX_DELAY_MS,
@@ -413,12 +413,12 @@ async fn ensure_session(
std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
}
} else {
kb_onchain_transport::WsReconnectPolicy::disabled()
ks_onchain_transport::WsReconnectPolicy::disabled()
};
let capabilities = kb_onchain_transport::StandardWsCapabilities::from_endpoint(
let capabilities = ks_onchain_transport::StandardWsCapabilities::from_endpoint(
selected_client.endpoint_config(),
);
let session = match kb_onchain_transport::WsSession::connect(
let session = match ks_onchain_transport::WsSession::connect(
selected_client,
capabilities,
reconnect_policy,
@@ -438,7 +438,7 @@ async fn ensure_session(
fn spawn_event_bridge(
app_handle: tauri::AppHandle,
session: std::sync::Arc<kb_onchain_transport::WsSession>,
session: std::sync::Arc<ks_onchain_transport::WsSession>,
) {
let mut receiver = session.subscribe_events();
tauri::async_runtime::spawn(async move {
@@ -460,7 +460,7 @@ fn spawn_event_bridge(
std::result::Result::Err(tokio::sync::broadcast::error::RecvError::Closed) => break,
};
match event {
kb_onchain_transport::WsSessionEvent::Notification { notification, .. } => {
ks_onchain_transport::WsSessionEvent::Notification { notification, .. } => {
let compact_payload = match serde_json::to_string(&notification) {
std::result::Result::Ok(payload) => payload,
std::result::Result::Err(error) => {
@@ -480,10 +480,10 @@ fn spawn_event_bridge(
emit_message(&app_handle, "notification", truncate_payload(ui_payload));
}
},
kb_onchain_transport::WsSessionEvent::Diagnostic { code, message } => {
ks_onchain_transport::WsSessionEvent::Diagnostic { code, message } => {
emit_message(&app_handle, &code, truncate_payload(message));
},
kb_onchain_transport::WsSessionEvent::Reconnecting {
ks_onchain_transport::WsSessionEvent::Reconnecting {
attempt,
maximum_attempts,
} => {
@@ -494,7 +494,7 @@ fn spawn_event_bridge(
);
emit_status(&app_handle, session.snapshot().await);
},
kb_onchain_transport::WsSessionEvent::Reconnected { reconnect_count } => {
ks_onchain_transport::WsSessionEvent::Reconnected { reconnect_count } => {
emit_message(
&app_handle,
"reconnected",
@@ -502,13 +502,13 @@ fn spawn_event_bridge(
);
emit_status(&app_handle, session.snapshot().await);
},
kb_onchain_transport::WsSessionEvent::Connected
| kb_onchain_transport::WsSessionEvent::SubscriptionAdded(_)
| kb_onchain_transport::WsSessionEvent::SubscriptionRemapped { .. }
| kb_onchain_transport::WsSessionEvent::SubscriptionRemoved(_) => {
ks_onchain_transport::WsSessionEvent::Connected
| ks_onchain_transport::WsSessionEvent::SubscriptionAdded(_)
| ks_onchain_transport::WsSessionEvent::SubscriptionRemapped { .. }
| ks_onchain_transport::WsSessionEvent::SubscriptionRemoved(_) => {
emit_status(&app_handle, session.snapshot().await);
},
kb_onchain_transport::WsSessionEvent::Disconnected => {
ks_onchain_transport::WsSessionEvent::Disconnected => {
emit_status(&app_handle, session.snapshot().await);
break;
},
@@ -517,7 +517,7 @@ fn spawn_event_bridge(
});
}
fn emit_status(app_handle: &tauri::AppHandle, snapshot: kb_onchain_transport::WsSessionSnapshot) {
fn emit_status(app_handle: &tauri::AppHandle, snapshot: ks_onchain_transport::WsSessionSnapshot) {
let window = match app_handle.get_webview_window("demo_ws") {
std::option::Option::Some(window) => window,
std::option::Option::None => return,
@@ -542,7 +542,7 @@ fn emit_message(app_handle: &tauri::AppHandle, kind: &str, payload_json: std::st
}
fn status_from_snapshot(
snapshot: kb_onchain_transport::WsSessionSnapshot,
snapshot: ks_onchain_transport::WsSessionSnapshot,
) -> crate::DemoWsStatusPayload {
let mut subscriptions = std::vec::Vec::new();
for subscription in &snapshot.subscriptions {
@@ -567,7 +567,7 @@ fn status_from_snapshot(
},
};
return crate::DemoWsStatusPayload {
connected: snapshot.state != kb_onchain_transport::WsSessionState::Disconnected,
connected: snapshot.state != ks_onchain_transport::WsSessionState::Disconnected,
endpoint_name: std::option::Option::Some(snapshot.endpoint_name),
endpoint_url: std::option::Option::Some(snapshot.endpoint_url),
method,
@@ -595,7 +595,7 @@ fn disconnected_status() -> crate::DemoWsStatusPayload {
}
fn build_ws_role_options(
snapshots: std::vec::Vec<kb_onchain_transport::WsPoolClientSnapshot>,
snapshots: std::vec::Vec<ks_onchain_transport::WsPoolClientSnapshot>,
) -> std::vec::Vec<crate::DemoWsRoleOption> {
let mut roles = std::collections::BTreeMap::<
std::string::String,
@@ -635,7 +635,7 @@ fn build_ws_method_options() -> std::vec::Vec<crate::DemoWsMethodOption> {
("voteSubscribe", ("Votes", false, false, false)),
]);
let mut options = std::vec::Vec::new();
for specification in &kb_onchain_transport::STANDARD_WS_SUBSCRIPTIONS {
for specification in &ks_onchain_transport::STANDARD_WS_SUBSCRIPTIONS {
let metadata = labels.get(specification.subscribe_method);
let (label, requires_target, requires_filter_json, supports_config_json) = match metadata {
std::option::Option::Some(metadata) => *metadata,
@@ -644,7 +644,7 @@ fn build_ws_method_options() -> std::vec::Vec<crate::DemoWsMethodOption> {
options.push(crate::DemoWsMethodOption {
method: specification.subscribe_method.to_string(),
unsubscribe_method: specification.unsubscribe_method.to_string(),
request_kind: kb_onchain_transport::request_kind_from_method(
request_kind: ks_onchain_transport::request_kind_from_method(
specification.subscribe_method,
),
label: label.to_string(),
@@ -661,7 +661,7 @@ fn build_standard_ws_request(
target: std::option::Option<std::string::String>,
filter_json: std::option::Option<std::string::String>,
config_json: std::option::Option<std::string::String>,
) -> std::result::Result<kb_onchain_transport::StandardWsRequest, std::string::String> {
) -> std::result::Result<ks_onchain_transport::StandardWsRequest, std::string::String> {
return match method {
"accountSubscribe" => {
let target = match required_target(target, method) {
@@ -669,7 +669,7 @@ fn build_standard_ws_request(
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
let mut config = match parse_optional_json_as::<
kb_onchain_transport::WsAccountSubscribeConfig,
ks_onchain_transport::WsAccountSubscribeConfig,
>(config_json, "configJson")
{
std::result::Result::Ok(config) => config.unwrap_or_default(),
@@ -677,15 +677,15 @@ fn build_standard_ws_request(
};
if config.encoding.is_none() {
config.encoding =
std::option::Option::Some(kb_onchain_transport::RpcAccountEncoding::Base64);
std::option::Option::Some(ks_onchain_transport::RpcAccountEncoding::Base64);
}
if let std::result::Result::Err(error) =
reject_present(filter_json, "filterJson", method)
{
return std::result::Result::Err(error);
}
std::result::Result::Ok(kb_onchain_transport::StandardWsRequest::Account(
kb_onchain_transport::AccountSubscribeRequest {
std::result::Result::Ok(ks_onchain_transport::StandardWsRequest::Account(
ks_onchain_transport::AccountSubscribeRequest {
pubkey: target,
config: std::option::Option::Some(config),
},
@@ -695,44 +695,44 @@ fn build_standard_ws_request(
if let std::result::Result::Err(error) = reject_present(target, "target", method) {
return std::result::Result::Err(error);
}
let filter = match parse_required_json_as::<kb_onchain_transport::WsBlockFilter>(
let filter = match parse_required_json_as::<ks_onchain_transport::WsBlockFilter>(
filter_json,
"filterJson",
) {
std::result::Result::Ok(filter) => filter,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
let config = match parse_optional_json_as::<kb_onchain_transport::WsBlockSubscribeConfig>(
let config = match parse_optional_json_as::<ks_onchain_transport::WsBlockSubscribeConfig>(
config_json,
"configJson",
) {
std::result::Result::Ok(config) => config,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
std::result::Result::Ok(kb_onchain_transport::StandardWsRequest::Block(
kb_onchain_transport::BlockSubscribeRequest { filter, config },
std::result::Result::Ok(ks_onchain_transport::StandardWsRequest::Block(
ks_onchain_transport::BlockSubscribeRequest { filter, config },
))
},
"logsSubscribe" => {
if let std::result::Result::Err(error) = reject_present(target, "target", method) {
return std::result::Result::Err(error);
}
let filter = match parse_required_json_as::<kb_onchain_transport::WsLogsFilter>(
let filter = match parse_required_json_as::<ks_onchain_transport::WsLogsFilter>(
filter_json,
"filterJson",
) {
std::result::Result::Ok(filter) => filter,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
let config = match parse_optional_json_as::<kb_onchain_transport::WsLogsSubscribeConfig>(
let config = match parse_optional_json_as::<ks_onchain_transport::WsLogsSubscribeConfig>(
config_json,
"configJson",
) {
std::result::Result::Ok(config) => config,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
std::result::Result::Ok(kb_onchain_transport::StandardWsRequest::Logs(
kb_onchain_transport::LogsSubscribeRequest { filter, config },
std::result::Result::Ok(ks_onchain_transport::StandardWsRequest::Logs(
ks_onchain_transport::LogsSubscribeRequest { filter, config },
))
},
"programSubscribe" => {
@@ -746,7 +746,7 @@ fn build_standard_ws_request(
return std::result::Result::Err(error);
}
let mut config = match parse_optional_json_as::<
kb_onchain_transport::WsProgramSubscribeConfig,
ks_onchain_transport::WsProgramSubscribeConfig,
>(config_json, "configJson")
{
std::result::Result::Ok(config) => config.unwrap_or_default(),
@@ -754,10 +754,10 @@ fn build_standard_ws_request(
};
if config.encoding.is_none() {
config.encoding =
std::option::Option::Some(kb_onchain_transport::RpcAccountEncoding::Base64);
std::option::Option::Some(ks_onchain_transport::RpcAccountEncoding::Base64);
}
std::result::Result::Ok(kb_onchain_transport::StandardWsRequest::Program(
kb_onchain_transport::ProgramSubscribeRequest {
std::result::Result::Ok(ks_onchain_transport::StandardWsRequest::Program(
ks_onchain_transport::ProgramSubscribeRequest {
program_id: target,
config: std::option::Option::Some(config),
},
@@ -774,14 +774,14 @@ fn build_standard_ws_request(
return std::result::Result::Err(error);
}
let config = match parse_optional_json_as::<
kb_onchain_transport::WsSignatureSubscribeConfig,
ks_onchain_transport::WsSignatureSubscribeConfig,
>(config_json, "configJson")
{
std::result::Result::Ok(config) => config,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
std::result::Result::Ok(kb_onchain_transport::StandardWsRequest::Signature(
kb_onchain_transport::SignatureSubscribeRequest { signature: target, config },
std::result::Result::Ok(ks_onchain_transport::StandardWsRequest::Signature(
ks_onchain_transport::SignatureSubscribeRequest { signature: target, config },
))
},
"rootSubscribe" => {
@@ -790,8 +790,8 @@ fn build_standard_ws_request(
{
return std::result::Result::Err(error);
}
std::result::Result::Ok(kb_onchain_transport::StandardWsRequest::Root(
kb_onchain_transport::RootSubscribeRequest,
std::result::Result::Ok(ks_onchain_transport::StandardWsRequest::Root(
ks_onchain_transport::RootSubscribeRequest,
))
},
"slotSubscribe" => {
@@ -800,8 +800,8 @@ fn build_standard_ws_request(
{
return std::result::Result::Err(error);
}
std::result::Result::Ok(kb_onchain_transport::StandardWsRequest::Slot(
kb_onchain_transport::SlotSubscribeRequest,
std::result::Result::Ok(ks_onchain_transport::StandardWsRequest::Slot(
ks_onchain_transport::SlotSubscribeRequest,
))
},
"slotsUpdatesSubscribe" => {
@@ -810,8 +810,8 @@ fn build_standard_ws_request(
{
return std::result::Result::Err(error);
}
std::result::Result::Ok(kb_onchain_transport::StandardWsRequest::SlotsUpdates(
kb_onchain_transport::SlotsUpdatesSubscribeRequest,
std::result::Result::Ok(ks_onchain_transport::StandardWsRequest::SlotsUpdates(
ks_onchain_transport::SlotsUpdatesSubscribeRequest,
))
},
"voteSubscribe" => {
@@ -820,8 +820,8 @@ fn build_standard_ws_request(
{
return std::result::Result::Err(error);
}
std::result::Result::Ok(kb_onchain_transport::StandardWsRequest::Vote(
kb_onchain_transport::VoteSubscribeRequest,
std::result::Result::Ok(ks_onchain_transport::StandardWsRequest::Vote(
ks_onchain_transport::VoteSubscribeRequest,
))
},
_ => std::result::Result::Err(format!("unsupported standard WebSocket method '{method}'")),
@@ -930,30 +930,30 @@ mod tests {
std::option::Option::None,
);
let account = match account {
std::result::Result::Ok(kb_onchain_transport::StandardWsRequest::Account(value)) => {
std::result::Result::Ok(ks_onchain_transport::StandardWsRequest::Account(value)) => {
value
},
_ => panic!("accountSubscribe request was not built"),
};
assert_eq!(
account.config.and_then(|value| return value.encoding),
std::option::Option::Some(kb_onchain_transport::RpcAccountEncoding::Base64)
std::option::Option::Some(ks_onchain_transport::RpcAccountEncoding::Base64)
);
let program = super::build_standard_ws_request(
"programSubscribe",
std::option::Option::Some(kb_program_ids::SPL_TOKEN_2022_PROGRAM_ID.to_string()),
std::option::Option::Some(ks_program_ids::SPL_TOKEN_2022_PROGRAM_ID.to_string()),
std::option::Option::None,
std::option::Option::Some(r#"{"encoding":"jsonParsed"}"#.to_string()),
);
let program = match program {
std::result::Result::Ok(kb_onchain_transport::StandardWsRequest::Program(value)) => {
std::result::Result::Ok(ks_onchain_transport::StandardWsRequest::Program(value)) => {
value
},
_ => panic!("programSubscribe request was not built"),
};
assert_eq!(
program.config.and_then(|value| return value.encoding),
std::option::Option::Some(kb_onchain_transport::RpcAccountEncoding::JsonParsed)
std::option::Option::Some(ks_onchain_transport::RpcAccountEncoding::JsonParsed)
);
}

6
kb-app-demo-desktop/src/main_window.rs
View File

@@ -1,5 +1,5 @@
// file: kb-app-demo-desktop/src/main_window.rs
// version: 1
// version: 2
//! Main-window helpers and workspace README loading.
@@ -11,12 +11,12 @@ pub(crate) fn workspace_root_dir() -> std::path::PathBuf {
};
}
pub(crate) fn load_project_readme() -> kb_core::Result<std::string::String> {
pub(crate) fn load_project_readme() -> ks_core::Result<std::string::String> {
let path = crate::workspace_root_dir().join("README.md");
let content = match std::fs::read_to_string(&path) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => {
return std::result::Result::Err(kb_core::Error::io(format!(
return std::result::Result::Err(ks_core::Error::io(format!(
"cannot read project README '{}': {error}",
path.display()
)));

22
kb-app-demo-desktop/src/tauri.rs
View File

@@ -1,5 +1,5 @@
// file: kb-app-demo-desktop/src/tauri.rs
// version: 34
// version: 35
//! Tauri runtime assembly and private command wrappers.
@@ -9,7 +9,7 @@ use tauri::Manager; // rust-rules: trait-import
#[cfg_attr(mobile, tauri::mobile_entry_point)]
#[allow(clippy::question_mark_used)]
#[allow(clippy::question_mark)]
pub fn run() -> kb_core::Result<()> {
pub fn run() -> ks_core::Result<()> {
let rustls_result = install_default_rustls_provider();
if let std::result::Result::Err(error) = rustls_result {
return std::result::Result::Err(error);
@@ -131,20 +131,20 @@ pub fn run() -> kb_core::Result<()> {
let run_result = builder.run(tauri::generate_context!());
return match run_result {
std::result::Result::Ok(()) => std::result::Result::Ok(()),
std::result::Result::Err(error) => std::result::Result::Err(kb_core::Error::tauri(
std::result::Result::Err(error) => std::result::Result::Err(ks_core::Error::tauri(
format!("cannot run desktop demo application: {error:?}"),
)),
};
}
fn install_default_rustls_provider() -> kb_core::Result<()> {
fn install_default_rustls_provider() -> ks_core::Result<()> {
if rustls::crypto::CryptoProvider::get_default().is_some() {
return std::result::Result::Ok(());
}
let provider_result = rustls::crypto::aws_lc_rs::default_provider().install_default();
return match provider_result {
std::result::Result::Ok(()) => std::result::Result::Ok(()),
std::result::Result::Err(error) => std::result::Result::Err(kb_core::Error::invalid_state(
std::result::Result::Err(error) => std::result::Result::Err(ks_core::Error::invalid_state(
format!("cannot install default rustls crypto provider: {error:?}"),
)),
};
@@ -160,12 +160,12 @@ fn open_or_focus_demo_window(
if let std::option::Option::Some(window) = app_handle.get_webview_window(label) {
if let std::result::Result::Err(error) = window.show() {
return std::result::Result::Err(
kb_core::Error::tauri(format!("cannot show {label} window: {error}")).to_string(),
ks_core::Error::tauri(format!("cannot show {label} window: {error}")).to_string(),
);
}
if let std::result::Result::Err(error) = window.set_focus() {
return std::result::Result::Err(
kb_core::Error::tauri(format!("cannot focus {label} window: {error}")).to_string(),
ks_core::Error::tauri(format!("cannot focus {label} window: {error}")).to_string(),
);
}
return std::result::Result::Ok(());
@@ -185,12 +185,12 @@ fn open_or_focus_demo_window(
std::result::Result::Ok(window) => match window.set_focus() {
std::result::Result::Ok(()) => std::result::Result::Ok(()),
std::result::Result::Err(error) => std::result::Result::Err(
kb_core::Error::tauri(format!("cannot focus created {label} window: {error}"))
ks_core::Error::tauri(format!("cannot focus created {label} window: {error}"))
.to_string(),
),
},
std::result::Result::Err(error) => std::result::Result::Err(
kb_core::Error::tauri(format!("cannot create {label} window: {error}")).to_string(),
ks_core::Error::tauri(format!("cannot create {label} window: {error}")).to_string(),
),
};
}
@@ -256,7 +256,7 @@ fn open_demo_http_window(
#[tauri::command]
fn demo_http_list_pool_clients(
state: tauri::State<'_, crate::AppState>,
) -> std::vec::Vec<kb_onchain_transport::HttpPoolClientSnapshot> {
) -> std::vec::Vec<ks_onchain_transport::HttpPoolClientSnapshot> {
return crate::demo_http_list_pool_clients(state);
}
@@ -284,7 +284,7 @@ fn open_demo_ws_window(
fn demo_ws_list_pool_clients(
state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<
std::vec::Vec<kb_onchain_transport::WsPoolClientSnapshot>,
std::vec::Vec<ks_onchain_transport::WsPoolClientSnapshot>,
std::string::String,
> {
return crate::demo_ws_list_pool_clients(state);