v0.1.0-pre.053

kb-app-demo-desktop/src/tauri.rs

@@ -64,6 +64,21 @@ pub fn run() -> kb_core::Result<()> {
         load_demo_sql_replay_programs,
         load_demo_sql_replay_entities,
         export_demo_sql_replay_csv,
+        demo_execution_solana_core_options,
+        demo_execution_solana_core_generate_recipient,
+        demo_execution_solana_core_execute,
+        open_demo_execution_solana_core_window,
+        demo_execution_spl_memo_execute,
+        demo_execution_solana_core_cancel,
+        open_demo_execution_spl_window,
+        demo_execution_spl_validation_scenarios,
+        demo_execution_spl_token_execute,
+        demo_spl_token_journal,
+        demo_execution_spl_token2022_execute,
+        demo_spl_token2022_fixture,
+        demo_spl_ata_derive,
+        demo_execution_spl_ata_execute,
+        demo_spl_ata_journal,
         open_demo_core_extraction_window,
         demo_core_extraction_options,
         demo_core_extraction_execute,
@@ -1307,3 +1322,867 @@ async fn load_demo_sql_replay_entities(
     }
     return std::result::Result::Ok(output);
 }
+
+/// Opens or focuses the Solana Core execution demo window.
+#[tauri::command]
+fn open_demo_execution_solana_core_window(
+    app_handle: tauri::AppHandle,
+) -> std::result::Result<(), std::string::String> {
+    let existing_window = app_handle.get_webview_window("demo_execution_solana_core");
+    if let std::option::Option::Some(window) = existing_window {
+        let show_result = window.show();
+        if let std::result::Result::Err(error) = show_result {
+            return std::result::Result::Err(error.to_string());
+        }
+        let focus_result = window.set_focus();
+        if let std::result::Result::Err(error) = focus_result {
+            return std::result::Result::Err(error.to_string());
+        }
+        return std::result::Result::Ok(());
+    }
+    let build_result = tauri::WebviewWindowBuilder::new(
+        &app_handle,
+        "demo_execution_solana_core",
+        tauri::WebviewUrl::App("demo_execution_solana_core.html".into()),
+    )
+    .title("Khadhroony Bot3 - Exécution Solana Devnet")
+    .inner_size(1360.0, 920.0)
+    .min_inner_size(1040.0, 700.0)
+    .resizable(true)
+    .visible(true)
+    .build();
+    return match build_result {
+        std::result::Result::Ok(window) => {
+            let focus_result = window.set_focus();
+            if let std::result::Result::Err(error) = focus_result {
+                return std::result::Result::Err(error.to_string());
+            }
+            std::result::Result::Ok(())
+        },
+        std::result::Result::Err(error) => std::result::Result::Err(error.to_string()),
+    };
+}
+
+/// Returns compatible Devnet profiles and conservative defaults.
+#[tauri::command]
+fn demo_execution_solana_core_options(
+    state: tauri::State<'_, crate::AppState>,
+) -> crate::DemoExecutionSolanaCoreOptionsPayload {
+    let profiles = crate::devnet_profile_options(state.app_config());
+    let default_profile_name = profiles.first().map(|profile| return profile.name.clone());
+    return crate::DemoExecutionSolanaCoreOptionsPayload {
+        profiles,
+        default_profile_name,
+        default_transfer_lamports: 1_000_000,
+        running: state
+            .demo_execution_solana_core_running()
+            .load(std::sync::atomic::Ordering::Acquire),
+    };
+}
+
+/// Generates a disposable recipient public key without exposing its private key.
+#[tauri::command]
+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") {
+        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);
+    return std::result::Result::Ok(crate::DemoExecutionSolanaCoreGeneratedRecipientPayload {
+        public_key: wallet.public_key(),
+    });
+}
+
+/// Executes one bounded System transfer simulation or Devnet submission.
+#[tauri::command]
+#[allow(clippy::question_mark_used)]
+async fn demo_execution_solana_core_execute(
+    app_handle: tauri::AppHandle,
+    state: tauri::State<'_, crate::AppState>,
+    request: crate::DemoExecutionSolanaCoreRequest,
+) -> std::result::Result<crate::DemoExecutionSolanaCoreSummaryPayload, std::string::String> {
+    let acquire_result = state.demo_execution_solana_core_running().compare_exchange(
+        false,
+        true,
+        std::sync::atomic::Ordering::AcqRel,
+        std::sync::atomic::Ordering::Acquire,
+    );
+    if acquire_result.is_err() {
+        return std::result::Result::Err("a Solana Core execution is already running".to_string());
+    }
+    let _run_guard = crate::DemoExecutionSolanaCoreRunGuard {
+        running: state.demo_execution_solana_core_running(),
+    };
+    state
+        .demo_execution_solana_core_cancel_requested()
+        .store(false, std::sync::atomic::Ordering::Release);
+    let profile =
+        match crate::select_devnet_profile(state.app_config(), request.profile_name.as_str()) {
+            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) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
+    };
+    let store = match crate::connect_postgres_store(&profile).await {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
+    };
+    let initialize_result = store.initialize_store_schema().await;
+    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(
+        format!("demo-execution-{}", chrono::Utc::now().timestamp_micros()),
+        kb_lib::MdPubkey(request.recipient.trim().to_string()),
+        request.lamports,
+    );
+    pipeline_request.airdrop_lamports = request.airdrop_lamports;
+    pipeline_request.submit = request.submit;
+    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;
+    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>> =
+        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),
+            ]
+        } else {
+            std::vec::Vec::new()
+        };
+    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_system_transfer(
+        &http_pool,
+        &store,
+        &profile,
+        workspace_root.as_path(),
+        &pipeline_request,
+        decoders.as_slice(),
+        materializers.as_slice(),
+        &observer,
+    )
+    .await
+    {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
+    };
+    return std::result::Result::Ok(crate::demo_execution_solana_core_summary_payload(summary));
+}
+
+/// Executes one Memo v4 simulation or explicitly authorized Devnet submission.
+#[tauri::command]
+#[allow(clippy::question_mark_used)]
+async fn demo_execution_spl_memo_execute(
+    app_handle: tauri::AppHandle,
+    state: tauri::State<'_, crate::AppState>,
+    request: crate::DemoExecutionMemoRequest,
+) -> std::result::Result<crate::DemoExecutionMemoSummaryPayload, std::string::String> {
+    let acquire_result = state.demo_execution_solana_core_running().compare_exchange(
+        false,
+        true,
+        std::sync::atomic::Ordering::AcqRel,
+        std::sync::atomic::Ordering::Acquire,
+    );
+    if acquire_result.is_err() {
+        return std::result::Result::Err("a Devnet execution is already running".to_string());
+    }
+    let _run_guard = crate::DemoExecutionSolanaCoreRunGuard {
+        running: state.demo_execution_solana_core_running(),
+    };
+    state
+        .demo_execution_solana_core_cancel_requested()
+        .store(false, std::sync::atomic::Ordering::Release);
+    let profile =
+        match crate::select_devnet_profile(state.app_config(), request.profile_name.as_str()) {
+            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) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
+    };
+    let store = match crate::connect_postgres_store(&profile).await {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
+    };
+    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(
+        format!("demo-memo-execution-{}", chrono::Utc::now().timestamp_micros()),
+        request.message,
+    );
+    pipeline_request.include_wallet_as_memo_signer = request.include_wallet_as_memo_signer;
+    pipeline_request.submit = request.submit;
+    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 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(
+        &http_pool,
+        &store,
+        &profile,
+        workspace_root.as_path(),
+        &pipeline_request,
+        decoders.as_slice(),
+        materializers.as_slice(),
+        &observer,
+    )
+    .await
+    {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
+    };
+    return std::result::Result::Ok(crate::demo_execution_solana_core_memo_summary_payload(
+        summary,
+    ));
+}
+
+/// Requests cooperative cancellation before the next execution stage.
+#[tauri::command]
+fn demo_execution_solana_core_cancel(state: tauri::State<'_, crate::AppState>) -> bool {
+    let running = state
+        .demo_execution_solana_core_running()
+        .load(std::sync::atomic::Ordering::Acquire);
+    if !running {
+        return false;
+    }
+    state
+        .demo_execution_solana_core_cancel_requested()
+        .store(true, std::sync::atomic::Ordering::Release);
+    return true;
+}
+
+/// Returns the complete ordered Devnet SPL validation inventory for milestone 0.4.6.
+#[tauri::command]
+fn demo_execution_spl_validation_scenarios()
+-> std::vec::Vec<crate::DevnetSplValidationScenarioPayload> {
+    return kb_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 => {
+                        "token2022_public".to_string()
+                    },
+                    kb_pipeline_demo_scenarios::DevnetSplValidationFamily::ElGamalRegistry => {
+                        "elgamal_registry".to_string()
+                    },
+                    kb_pipeline_demo_scenarios::DevnetSplValidationFamily::Token2022Confidential => {
+                        "token2022_confidential".to_string()
+                    },
+                },
+                operation_code: scenario.operation_code,
+                implementation_status: match scenario.implementation_status {
+                    kb_pipeline_demo_scenarios::DevnetSplValidationImplementationStatus::Executable => {
+                        "executable".to_string()
+                    },
+                    kb_pipeline_demo_scenarios::DevnetSplValidationImplementationStatus::BackendReady => {
+                        "backend_ready".to_string()
+                    },
+                    kb_pipeline_demo_scenarios::DevnetSplValidationImplementationStatus::ProofFixtureRequired => {
+                        "proof_fixture_required".to_string()
+                    },
+                },
+                proof_required: scenario.proof_required,
+                required_fixture_variables: scenario.required_fixture_variables,
+            };
+        })
+        .collect();
+}
+
+/// Opens or focuses the dedicated SPL execution window.
+#[tauri::command]
+fn open_demo_execution_spl_window(
+    app_handle: tauri::AppHandle,
+) -> std::result::Result<(), std::string::String> {
+    tracing::info!(target: crate::TRACING_TARGET, "open SPL Devnet execution window");
+    let existing_window = app_handle.get_webview_window("demo_execution_spl");
+    if let std::option::Option::Some(window) = existing_window {
+        let show_result = window.show();
+        if let std::result::Result::Err(error) = show_result {
+            return std::result::Result::Err(error.to_string());
+        }
+        let focus_result = window.set_focus();
+        if let std::result::Result::Err(error) = focus_result {
+            return std::result::Result::Err(error.to_string());
+        }
+        return std::result::Result::Ok(());
+    }
+    let build_result = tauri::WebviewWindowBuilder::new(
+        &app_handle,
+        "demo_execution_spl",
+        tauri::WebviewUrl::App("demo_execution_spl.html".into()),
+    )
+    .title("Khadhroony Bot3 - Exécution SPL Devnet")
+    .inner_size(1500.0, 960.0)
+    .min_inner_size(1120.0, 720.0)
+    .resizable(true)
+    .visible(true)
+    .build();
+    return match build_result {
+        std::result::Result::Ok(window) => {
+            let focus_result = window.set_focus();
+            if let std::result::Result::Err(error) = focus_result {
+                return std::result::Result::Err(error.to_string());
+            }
+            std::result::Result::Ok(())
+        },
+        std::result::Result::Err(error) => std::result::Result::Err(error.to_string()),
+    };
+}
+
+/// Executes one checked SPL Token simulation or explicitly authorized Devnet submission.
+#[tauri::command]
+#[allow(clippy::question_mark_used)]
+async fn demo_execution_spl_token_execute(
+    app_handle: tauri::AppHandle,
+    state: tauri::State<'_, crate::AppState>,
+    request: crate::DemoExecutionSplTokenRequest,
+) -> std::result::Result<crate::DemoExecutionSplTokenSummaryPayload, std::string::String> {
+    let acquire_result = state.demo_execution_solana_core_running().compare_exchange(
+        false,
+        true,
+        std::sync::atomic::Ordering::AcqRel,
+        std::sync::atomic::Ordering::Acquire,
+    );
+    if acquire_result.is_err() {
+        return std::result::Result::Err("a Devnet execution is already running".to_string());
+    }
+    let _run_guard = crate::DemoExecutionSolanaCoreRunGuard {
+        running: state.demo_execution_solana_core_running(),
+    };
+    state
+        .demo_execution_solana_core_cancel_requested()
+        .store(false, std::sync::atomic::Ordering::Release);
+    let profile =
+        match crate::select_devnet_profile(state.app_config(), request.profile_name.as_str()) {
+            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) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
+    };
+    let store = match crate::connect_postgres_store(&profile).await {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
+    };
+    if let std::result::Result::Err(error) = store.initialize_store_schema().await {
+        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()),
+                multisig_signers: std::vec::Vec::new(),
+            },
+            amount: kb_lib::ExSplClassicTokenAmount(amount_raw.clone()),
+            decimals: request.decimals,
+        },
+    };
+    let mut pipeline_request = kb_pipeline_demo_scenarios::DevnetSplTokenExecutionRequest::new(
+        format!("demo-spl-token-execution-{}", chrono::Utc::now().timestamp_micros()),
+        operation,
+    );
+    pipeline_request.submit = request.submit;
+    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 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(
+        &http_pool,
+        &store,
+        &profile,
+        workspace_root.as_path(),
+        &pipeline_request,
+        decoders.as_slice(),
+        materializers.as_slice(),
+        &observer,
+    )
+    .await
+    {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
+    };
+    return std::result::Result::Ok(crate::demo_spl_token_summary_payload(
+        summary,
+        amount_raw,
+        request.decimals,
+    ));
+}
+
+/// Loads a bounded, typed journal of committed classic SPL Token projections.
+#[tauri::command]
+#[allow(clippy::question_mark_used)]
+async fn demo_spl_token_journal(
+    state: tauri::State<'_, crate::AppState>,
+    request: crate::DemoSplTokenJournalRequest,
+) -> std::result::Result<std::vec::Vec<crate::DemoSplTokenJournalRow>, std::string::String> {
+    let validated = match crate::validate_journal_request(request) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let profile =
+        match crate::select_devnet_profile(state.app_config(), validated.profile_name.as_str()) {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+    let store = match crate::connect_postgres_store(&profile).await {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
+    };
+    if let std::result::Result::Err(error) = store.initialize_store_schema().await {
+        return std::result::Result::Err(error.to_string());
+    }
+    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
+    } else {
+        validated.limit
+    };
+    let filter = match kb_store::MaterializedEventFilter::new(
+        std::option::Option::None,
+        validated.family.clone(),
+        validated.signature_contains.clone(),
+        query_limit,
+    ) {
+        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
+    {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
+    };
+    let mut output = std::vec::Vec::new();
+    for row in rows {
+        if row.source_decoder_name != "spl_token"
+            || !crate::payload_matches(&row.payload_json, &validated)
+        {
+            continue;
+        }
+        output.push(crate::demo_spl_token_journal_row(row));
+        if output.len() >= validated.limit as usize {
+            break;
+        }
+    }
+    return std::result::Result::Ok(output);
+}
+
+/// Derives the representative profile wallet ATA without exposing private key material.
+#[tauri::command]
+#[allow(clippy::question_mark_used)]
+async fn demo_spl_ata_derive(
+    state: tauri::State<'_, crate::AppState>,
+    request: crate::DemoSplAtaDerivationRequest,
+) -> std::result::Result<crate::DemoSplAtaDerivationPayload, std::string::String> {
+    let profile =
+        match crate::select_devnet_profile(state.app_config(), request.profile_name.as_str()) {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+    let wallet = match crate::load_profile_wallet(&profile).await {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let wallet_owner = wallet.public_key();
+    let token_program = match crate::parse_token_program(&request.token_program) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let associated_token_account = match crate::derive_ata(
+        wallet_owner.as_str(),
+        request.mint.trim(),
+        token_program.program_id(),
+    ) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    return std::result::Result::Ok(crate::DemoSplAtaDerivationPayload {
+        payer: wallet_owner.clone(),
+        wallet_owner,
+        token_program_id: token_program.program_id().to_string(),
+        associated_token_account,
+    });
+}
+
+/// Executes one representative Create or CreateIdempotent ATA flow.
+#[tauri::command]
+#[allow(clippy::question_mark_used)]
+async fn demo_execution_spl_ata_execute(
+    app_handle: tauri::AppHandle,
+    state: tauri::State<'_, crate::AppState>,
+    request: crate::DemoExecutionSplAtaRequest,
+) -> std::result::Result<crate::DemoExecutionSplAtaSummaryPayload, std::string::String> {
+    let acquired = state.demo_execution_solana_core_running().compare_exchange(
+        false,
+        true,
+        std::sync::atomic::Ordering::AcqRel,
+        std::sync::atomic::Ordering::Acquire,
+    );
+    if acquired.is_err() {
+        return std::result::Result::Err("a Devnet execution is already running".to_string());
+    }
+    let _run_guard = crate::DemoExecutionSolanaCoreRunGuard {
+        running: state.demo_execution_solana_core_running(),
+    };
+    state
+        .demo_execution_solana_core_cancel_requested()
+        .store(false, std::sync::atomic::Ordering::Release);
+    let profile =
+        match crate::select_devnet_profile(state.app_config(), request.profile_name.as_str()) {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+    let profile_wallet = match crate::load_profile_wallet(&profile).await {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    if request.wallet_owner.trim() != profile_wallet.public_key() {
+        return std::result::Result::Err(
+            "the representative ATA panel requires the profile wallet as wallet owner".to_string(),
+        );
+    }
+    let token_program = match crate::parse_token_program(&request.token_program) {
+        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 operation = match request.mode.as_str() {
+        "create" => kb_lib::ExSplAssociatedTokenAccountOperation::Create {
+            wallet_owner,
+            mint,
+            token_program,
+        },
+        "create_idempotent" => kb_lib::ExSplAssociatedTokenAccountOperation::CreateIdempotent {
+            wallet_owner,
+            mint,
+            token_program,
+        },
+        _ => {
+            return std::result::Result::Err(
+                "ATA mode must be create or create_idempotent".to_string(),
+            );
+        },
+    };
+    let mut pipeline_request =
+        kb_pipeline_demo_scenarios::DevnetSplAssociatedTokenAccountExecutionRequest::new(
+            format!("demo-spl-ata-execution-{}", chrono::Utc::now().timestamp_micros()),
+            operation,
+        );
+    pipeline_request.submit = request.submit;
+    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) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
+    };
+    let store = match crate::connect_postgres_store(&profile).await {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
+    };
+    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 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 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(
+        &http_pool,
+        &store,
+        &profile,
+        crate::workspace_root_dir().as_path(),
+        &pipeline_request,
+        decoders.as_slice(),
+        materializers.as_slice(),
+        &observer,
+    )
+    .await
+    {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
+    };
+    return std::result::Result::Ok(crate::demo_spl_ata_summary_payload(summary));
+}
+
+/// Loads a bounded journal of ATA-owned lifecycle facts.
+#[tauri::command]
+#[allow(clippy::question_mark_used)]
+async fn demo_spl_ata_journal(
+    state: tauri::State<'_, crate::AppState>,
+    request: crate::DemoSplAtaJournalRequest,
+) -> std::result::Result<std::vec::Vec<crate::DemoSplAtaJournalRow>, std::string::String> {
+    if request.limit == 0 || request.limit > 500 {
+        return std::result::Result::Err("ATA journal limit must be between 1 and 500".to_string());
+    }
+    let profile =
+        match crate::select_devnet_profile(state.app_config(), request.profile_name.as_str()) {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+    let store = match crate::connect_postgres_store(&profile).await {
+        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(
+        std::option::Option::Some("spl_token_accounts".to_string()),
+        std::option::Option::None,
+        request.signature_contains.clone(),
+        500,
+    ) {
+        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
+    {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
+    };
+    let mut output = std::vec::Vec::new();
+    for row in rows {
+        if row.source_decoder_name != "spl_associated_token_account"
+            || !crate::journal_matches(&row.payload_json, &request)
+        {
+            continue;
+        }
+        output.push(crate::journal_row(row));
+        if output.len() >= request.limit as usize {
+            break;
+        }
+    }
+    return std::result::Result::Ok(output);
+}
+
+/// Executes one public Token-2022 simulation or explicitly authorized Devnet submission.
+#[tauri::command]
+#[allow(clippy::question_mark_used)]
+async fn demo_execution_spl_token2022_execute(
+    app_handle: tauri::AppHandle,
+    state: tauri::State<'_, crate::AppState>,
+    request: crate::DemoExecutionSplToken2022Request,
+) -> std::result::Result<crate::DemoExecutionSplToken2022SummaryPayload, std::string::String> {
+    let acquire_result = state.demo_execution_solana_core_running().compare_exchange(
+        false,
+        true,
+        std::sync::atomic::Ordering::AcqRel,
+        std::sync::atomic::Ordering::Acquire,
+    );
+    if acquire_result.is_err() {
+        return std::result::Result::Err("a Devnet execution is already running".to_string());
+    }
+    let _run_guard = crate::DemoExecutionSolanaCoreRunGuard {
+        running: state.demo_execution_solana_core_running(),
+    };
+    state
+        .demo_execution_solana_core_cancel_requested()
+        .store(false, std::sync::atomic::Ordering::Release);
+    let profile =
+        match crate::select_devnet_profile(state.app_config(), request.profile_name.as_str()) {
+            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) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
+    };
+    let store = match crate::connect_postgres_store(&profile).await {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
+    };
+    if let std::result::Result::Err(error) = store.initialize_store_schema().await {
+        return std::result::Result::Err(error.to_string());
+    }
+    let operation = match crate::operation_from_request(&request) {
+        std::result::Result::Ok(value) => value,
+        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(
+        format!("demo-spl-token-2022-execution-{}", chrono::Utc::now().timestamp_micros()),
+        operation,
+    );
+    pipeline_request.submit = request.submit;
+    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 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_token2022(
+        &http_pool,
+        &store,
+        &profile,
+        workspace_root.as_path(),
+        &pipeline_request,
+        decoders.as_slice(),
+        materializers.as_slice(),
+        &observer,
+    )
+    .await
+    {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
+    };
+    return std::result::Result::Ok(crate::demo_spl_token2022_summary_payload(
+        request.scenario_id,
+        operation_code,
+        summary,
+    ));
+}
+
+/// Loads public Token-2022 fixture values without reading private key bytes.
+#[tauri::command]
+fn demo_spl_token2022_fixture(
+    state: tauri::State<'_, crate::AppState>,
+    profile_name: std::string::String,
+) -> std::result::Result<crate::DemoSplToken2022FixturePayload, std::string::String> {
+    let profile = match crate::select_devnet_profile(state.app_config(), profile_name.as_str()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let configured = std::path::PathBuf::from(profile.wallet.wallet_dir.as_str());
+    let wallet_dir = if configured.is_absolute() {
+        configured
+    } else {
+        crate::workspace_root_dir().join(configured)
+    };
+    let fixture_path = wallet_dir.join("spl_token2022_validation").join("fixture.env");
+    let contents = match std::fs::read_to_string(&fixture_path) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => {
+            return std::result::Result::Err(format!(
+                "unable to read Token-2022 fixture {}: {error}",
+                fixture_path.display()
+            ));
+        },
+    };
+    let values = crate::parse_fixture(contents.as_str());
+    let required = |name: &str| -> std::result::Result<std::string::String, std::string::String> {
+        return match values.get(name) {
+            std::option::Option::Some(value) if !value.trim().is_empty() => {
+                std::result::Result::Ok(value.clone())
+            },
+            _ => std::result::Result::Err(format!("Token-2022 fixture is missing {name}")),
+        };
+    };
+    let program_id = match required("TOKEN_2022_PROGRAM") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let mint = match required("TOKEN_2022_MINT") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let source = match required("TOKEN_2022_SOURCE") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let destination = match required("TOKEN_2022_DESTINATION") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let close_account = match required("TOKEN_2022_CLOSE_ACCOUNT") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let delegate = match required("TOKEN_2022_DELEGATE") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let authority = match required("TOKEN_2022_AUTHORITY") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let freeze_authority = match required("TOKEN_2022_FREEZE_AUTHORITY") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let decimals_text = match required("TOKEN_2022_DECIMALS") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let decimals = match decimals_text.parse::<u8>() {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => {
+            return std::result::Result::Err(format!("invalid TOKEN_2022_DECIMALS value: {error}"));
+        },
+    };
+    return std::result::Result::Ok(crate::DemoSplToken2022FixturePayload {
+        fixture_path: fixture_path.display().to_string(),
+        program_id,
+        mint,
+        source,
+        destination,
+        close_account,
+        delegate,
+        authority,
+        freeze_authority,
+        decimals,
+        default_amount_raw: values
+            .get("TOKEN_2022_TRANSFER_AMOUNT_RAW")
+            .cloned()
+            .unwrap_or_else(|| return "1".to_string()),
+    });
+}