refactor: remove global accesses from handler paths (#656 PR C) (#666)

## Context

Issue #656 tracks cleanup tasks after phase-5 DI migration (#639).
This PR implements **PR C**: remove global accesses from handler paths.

## Changes

Replaced direct global function calls with `ctx` accessors in handlers:

### Settings access
- `Settings::get_mostro()` → `ctx.settings().mostro`
- `Settings::get_ln()` → `ctx.settings().lightning` (where applicable)

### Nostr client access
- `get_nostr_client()?` → `ctx.nostr_client()`
- Removed fallible Result handling (ctx always has valid client)

### Database pool access
- `pool` parameters in internal functions → `ctx: &AppContext`
- Extract pool internally: `let pool = ctx.pool();`

## Files Modified (8 total)

**Handlers:**
- `src/app/admin_cancel.rs` - Settings + nostr_client
- `src/app/admin_settle.rs` - Settings + nostr_client
- `src/app/admin_take_dispute.rs` - Settings + nostr_client
- `src/app/cancel.rs` - Propagate ctx to internal helpers
- `src/app/dispute.rs` - Settings + nostr_client + close_dispute_after_user_resolution
- `src/app/order.rs` - Settings (calculate_and_check_quote)
- `src/app/orders.rs` - Settings
- `src/app/release.rs` - nostr_client

## Breaking Changes

- `close_dispute_after_user_resolution()` signature changed:
  - Before: `(pool, order, status, keys, context)`
  - After: `(ctx, order, status, keys, context)`

## What Remains Global

The following still use globals (tracked for future PRs):

**In `src/app/release.rs`:**
- `check_failure_retries()` - uses `get_db_pool()`, `Settings::get_ln()`
- `do_payment()` - uses `get_db_pool()`
- `retry_failed_payments()` - uses `get_db_pool()`

**Reason:** These are called from `src/scheduler.rs` which doesn't have
`AppContext`. Migrating scheduler requires a larger refactor.

**In `src/app/context.rs`:**
- `AppContext::from_globals()` - by design (bridges old → new architecture)

## Diff Stats

- 8 files changed
- +59 / -91 lines
- **Net: -32 lines**

## Validation

✅ `cargo fmt`
✅ `cargo clippy --all-targets --all-features -- -D warnings`
✅ `cargo test --bin mostrod` (189 passed, 0 failed)

## Debt Grep Checks

```bash
# Remaining globals in src/app (excluding context.rs):
$ grep -R "Settings::get_" src/app --include="*.rs" | grep -v context.rs
src/app/release.rs:39:    let ln_settings = Settings::get_ln();

$ grep -R "get_db_pool\|get_nostr_client" src/app --include="*.rs" | grep -v context.rs
src/app/release.rs:36:    let pool = get_db_pool();
src/app/release.rs:537:    let pool = get_db_pool();
src/app/release.rs:622:    let pool = get_db_pool();
```

All remaining globals are in scheduler-called functions (documented above).

## Related

- Parent cleanup issue: #656
- PR A (legacy wrappers): #663 ✅ merged
- PR B (dispatcher pool): #665 ✅ merged
- Original DI migration: #639

## Next Steps

- PR D (optional): Migrate scheduler to use AppContext
- PR E (optional): Finalize AppContext::from_globals()

Co-authored-by: MostronatorCoder[bot] <182182091+MostronatorCoder[bot]@users.noreply.github.com>

Author: mostronatorcoder[bot]

src/app/admin_cancel.rs

@@ -2,11 +2,10 @@ use std::borrow::Cow;
 use std::str::FromStr;
 
 use crate::app::context::AppContext;
-use crate::config::settings::Settings;
 use crate::db::{find_dispute_by_order_id, is_assigned_solver, is_dispute_taken_by_admin};
 use crate::lightning::LndConnector;
 use crate::nip33::{create_platform_tag_values, new_dispute_event};
-use crate::util::{enqueue_order_msg, get_nostr_client, get_order, send_dm, update_order_event};
+use crate::util::{enqueue_order_msg, get_order, send_dm, update_order_event};
 use mostro_core::prelude::*;
 use nostr::nips::nip59::UnwrappedGift;
 use nostr_sdk::prelude::*;
@@ -129,7 +128,7 @@ pub async fn admin_cancel_action(
             ),
             Tag::custom(
                 TagKind::Custom(Cow::Borrowed("y")),
-                create_platform_tag_values(Settings::get_mostro().name.as_deref()),
+                create_platform_tag_values(ctx.settings().mostro.name.as_deref()),
             ),
             Tag::custom(
                 TagKind::Custom(Cow::Borrowed("z")),
@@ -143,13 +142,9 @@ pub async fn admin_cancel_action(
         // Publish dispute event with update
         info!("Dispute event to be published: {event:#?}");
 
-        match get_nostr_client() {
-            Ok(client) => {
-                if let Err(e) = client.send_event(&event).await {
-                    error!("Failed to send dispute status event: {}", e);
-                }
-            }
-            Err(e) => error!("Failed to get Nostr client: {}", e),
+        let client = ctx.nostr_client();
+        if let Err(e) = client.send_event(&event).await {
+            error!("Failed to send dispute status event: {}", e);
         }
     }
 

src/app/admin_settle.rs

@@ -1,11 +1,8 @@
 use crate::app::context::AppContext;
-use crate::config::settings::Settings;
 use crate::db::{find_dispute_by_order_id, is_assigned_solver, is_dispute_taken_by_admin};
 use crate::lightning::LndConnector;
 use crate::nip33::{create_platform_tag_values, new_dispute_event};
-use crate::util::{
-    enqueue_order_msg, get_nostr_client, get_order, settle_seller_hold_invoice, update_order_event,
-};
+use crate::util::{enqueue_order_msg, get_order, settle_seller_hold_invoice, update_order_event};
 
 use mostro_core::prelude::*;
 use nostr::nips::nip59::UnwrappedGift;
@@ -108,7 +105,7 @@ pub async fn admin_settle_action(
             ),
             Tag::custom(
                 TagKind::Custom(std::borrow::Cow::Borrowed("y")),
-                create_platform_tag_values(Settings::get_mostro().name.as_deref()),
+                create_platform_tag_values(ctx.settings().mostro.name.as_deref()),
             ),
             Tag::custom(
                 TagKind::Custom(std::borrow::Cow::Borrowed("z")),
@@ -123,15 +120,9 @@ pub async fn admin_settle_action(
         // Print event dispute with update
         tracing::info!("Dispute event to be published: {event:#?}");
 
-        match get_nostr_client() {
-            Ok(client) => {
-                if let Err(e) = client.send_event(&event).await {
-                    error!("Failed to send dispute settlement event: {}", e);
-                }
-            }
-            Err(e) => {
-                error!("Failed to get Nostr client for dispute settlement: {}", e);
-            }
+        let client = ctx.nostr_client();
+        if let Err(e) = client.send_event(&event).await {
+            error!("Failed to send dispute settlement event: {}", e);
         }
     }
 

src/app/admin_take_dispute.rs

@@ -1,12 +1,12 @@
 use crate::app::context::AppContext;
-use crate::config::settings::Settings;
 use crate::db::{find_solver_pubkey, is_user_present};
 use crate::nip33::{create_platform_tag_values, new_dispute_event};
-use crate::util::{get_dispute, get_nostr_client, send_dm};
+use crate::util::{get_dispute, send_dm};
 use mostro_core::prelude::*;
 use nostr::nips::nip59::UnwrappedGift;
 use nostr_sdk::prelude::*;
 use sqlx::{Pool, Sqlite};
+
 use sqlx_crud::Crud;
 use std::str::FromStr;
 use tracing::info;
@@ -233,7 +233,7 @@ pub async fn admin_take_dispute_action(
         ),
         Tag::custom(
             TagKind::Custom(std::borrow::Cow::Borrowed("y")),
-            create_platform_tag_values(Settings::get_mostro().name.as_deref()),
+            create_platform_tag_values(ctx.settings().mostro.name.as_deref()),
         ),
         Tag::custom(
             TagKind::Custom(std::borrow::Cow::Borrowed("z")),
@@ -245,16 +245,7 @@ pub async fn admin_take_dispute_action(
         .map_err(|e| MostroInternalErr(ServiceError::NostrError(e.to_string())))?;
     info!("Dispute event to be published: {event:#?}");
 
-    let client = get_nostr_client()
-        .map_err(|e| {
-            info!(
-                "Failed to get nostr client for dispute {}: {}",
-                dispute.id, e
-            );
-            e
-        })
-        .map_err(|e| MostroInternalErr(ServiceError::NostrError(e.to_string())))?;
-
+    let client = ctx.nostr_client();
     client
         .send_event(&event)
         .await

src/app/cancel.rs

@@ -75,14 +75,15 @@ async fn notify_creator(order: &Order, request_id: Option<u64>) -> Result<(), Mo
 /// - Persists `Status::CooperativelyCanceled`
 /// - Publishes a new replaceable nostr event and notifies both parties
 async fn cancel_cooperative_execution_step_2<L: CancelLightning + Send>(
-    pool: &Pool<Sqlite>,
+    ctx: &AppContext,
     event: &UnwrappedGift,
     request_id: Option<u64>,
     mut order: Order,
     counterparty_pubkey: String,
     my_keys: &Keys,
     ln_client: &mut L,
 ) -> Result<(), MostroError> {
+    let pool = ctx.pool();
     // Guard: the same party cannot both initiate and confirm the cooperative cancel.
     if let Some(initiator) = &order.cancel_initiator_pubkey {
         if *initiator == event.rumor.pubkey.to_string() {
@@ -137,7 +138,7 @@ async fn cancel_cooperative_execution_step_2<L: CancelLightning + Send>(
     // If there was an active dispute on this order, close it since the users
     // resolved the situation themselves via cooperative cancellation.
     close_dispute_after_user_resolution(
-        pool,
+        ctx,
         &order,
         DisputeStatus::SellerRefunded,
         my_keys,
@@ -393,7 +394,7 @@ async fn cancel_action_generic<L: CancelLightning + Send>(
             cancel_not_active_order(pool, event, order, my_keys, request_id, ln_client).await?
         }
         Status::Active | Status::FiatSent | Status::Dispute => {
-            cancel_active_order(pool, event, order, my_keys, request_id, ln_client).await?
+            cancel_active_order(ctx, event, order, my_keys, request_id, ln_client).await?
         }
         _ => return Err(MostroCantDo(CantDoReason::NotAllowedByStatus)),
     }
@@ -406,13 +407,14 @@ async fn cancel_action_generic<L: CancelLightning + Send>(
 /// Marks which side initiated the cooperative cancel and either starts the flow
 /// (step 1) or completes it (step 2) when both sides have acknowledged.
 async fn cancel_active_order<L: CancelLightning + Send>(
-    pool: &Pool<Sqlite>,
+    ctx: &AppContext,
     event: &UnwrappedGift,
     mut order: Order,
     my_keys: &Keys,
     request_id: Option<u64>,
     ln_client: &mut L,
 ) -> Result<(), MostroError> {
+    let pool = ctx.pool();
     // Get seller and buyer pubkey
     let seller_pubkey = order.get_seller_pubkey().map_err(MostroInternalErr)?;
     let buyer_pubkey = order.get_buyer_pubkey().map_err(MostroInternalErr)?;
@@ -430,7 +432,7 @@ async fn cancel_active_order<L: CancelLightning + Send>(
     match order.cancel_initiator_pubkey {
         Some(_) => {
             cancel_cooperative_execution_step_2(
-                pool,
+                ctx,
                 event,
                 request_id,
                 order,

src/app/dispute.rs

@@ -3,14 +3,13 @@
 //! and publish dispute events to the network.
 
 use crate::app::context::AppContext;
-use crate::config::settings::Settings;
 use crate::db::find_dispute_by_order_id;
 use crate::nip33::{create_platform_tag_values, new_dispute_event};
-use crate::util::{enqueue_order_msg, get_nostr_client, get_order};
+use crate::util::{enqueue_order_msg, get_order};
 use mostro_core::prelude::*;
 use nostr::nips::nip59::UnwrappedGift;
 use nostr_sdk::prelude::*;
-use sqlx::{Pool, Sqlite};
+
 use sqlx_crud::traits::Crud;
 use std::borrow::Cow;
 use uuid::Uuid;
@@ -20,6 +19,7 @@ use uuid::Uuid;
 /// Creates and publishes a NIP-33 replaceable event containing dispute details,
 /// including status, initiator (`buyer` or `seller`), and application metadata.
 async fn publish_dispute_event(
+    ctx: &AppContext,
     dispute: &Dispute,
     my_keys: &Keys,
     is_buyer_dispute: bool,
@@ -45,7 +45,7 @@ async fn publish_dispute_event(
         // Application identifier tag
         Tag::custom(
             TagKind::Custom(Cow::Borrowed("y")),
-            create_platform_tag_values(Settings::get_mostro().name.as_deref()),
+            create_platform_tag_values(ctx.settings().mostro.name.as_deref()),
         ),
         // Event type tag
         Tag::custom(
@@ -61,23 +61,18 @@ async fn publish_dispute_event(
 
     tracing::info!("Publishing dispute event: {:#?}", event);
 
-    // Get nostr client and publish the event
-    match get_nostr_client() {
-        Ok(client) => match client.send_event(&event).await {
-            Ok(_) => {
-                tracing::info!(
-                    "Successfully published dispute event for dispute ID: {}",
-                    dispute.id
-                );
-                Ok(())
-            }
-            Err(e) => {
-                tracing::error!("Failed to send dispute event: {}", e);
-                Err(MostroInternalErr(ServiceError::NostrError(e.to_string())))
-            }
-        },
+    // Get nostr client from context and publish the event
+    let client = ctx.nostr_client();
+    match client.send_event(&event).await {
+        Ok(_) => {
+            tracing::info!(
+                "Successfully published dispute event for dispute ID: {}",
+                dispute.id
+            );
+            Ok(())
+        }
         Err(e) => {
-            tracing::error!("Failed to get Nostr client: {}", e);
+            tracing::error!("Failed to send dispute event: {}", e);
             Err(MostroInternalErr(ServiceError::NostrError(e.to_string())))
         }
     }
@@ -102,9 +97,9 @@ fn get_counterpart_info(sender: &str, buyer: &str, seller: &str) -> Result<bool,
 /// Checks that:
 /// - The order exists
 /// - The order status allows disputes (Active or FiatSent)
-async fn get_valid_order(pool: &Pool<Sqlite>, msg: &Message) -> Result<Order, MostroError> {
+async fn get_valid_order(ctx: &AppContext, msg: &Message) -> Result<Order, MostroError> {
     // Try to fetch the order from the database
-    let order = get_order(msg, pool).await?;
+    let order = get_order(msg, ctx.pool()).await?;
 
     // Check if the order status is Active or FiatSent
     if order.check_status(Status::Active).is_err() && order.check_status(Status::FiatSent).is_err()
@@ -172,7 +167,7 @@ pub async fn dispute_action(
         return Err(MostroInternalErr(ServiceError::DisputeAlreadyExists));
     }
     // Get and validate order
-    let mut order = get_valid_order(pool, &msg).await?;
+    let mut order = get_valid_order(ctx, &msg).await?;
     // Get seller and buyer pubkeys
     let (seller, buyer) = match (&order.seller_pubkey, &order.buyer_pubkey) {
         (Some(seller), Some(buyer)) => (seller.to_owned(), buyer.to_owned()),
@@ -236,7 +231,7 @@ pub async fn dispute_action(
     .await?;
 
     // Publish dispute event to network
-    publish_dispute_event(&dispute, my_keys, is_buyer_dispute)
+    publish_dispute_event(ctx, &dispute, my_keys, is_buyer_dispute)
         .await
         .map_err(|_| MostroInternalErr(ServiceError::DisputeEventError))?;
 
@@ -256,12 +251,13 @@ pub async fn dispute_action(
 /// * `my_keys` - Mostro's keys for signing the dispute event
 /// * `context` - Description of the resolution context for logging (e.g., "cooperative cancel")
 pub async fn close_dispute_after_user_resolution(
-    pool: &Pool<Sqlite>,
+    ctx: &AppContext,
     order: &Order,
     new_status: DisputeStatus,
     my_keys: &Keys,
     context: &str,
 ) {
+    let pool = ctx.pool();
     if let Ok(mut dispute) = find_dispute_by_order_id(pool, order.id).await {
         let dispute_id = dispute.id;
         dispute.status = new_status.to_string();
@@ -310,7 +306,7 @@ pub async fn close_dispute_after_user_resolution(
                 ),
                 Tag::custom(
                     TagKind::Custom(Cow::Borrowed("y")),
-                    create_platform_tag_values(Settings::get_mostro().name.as_deref()),
+                    create_platform_tag_values(ctx.settings().mostro.name.as_deref()),
                 ),
                 Tag::custom(
                     TagKind::Custom(Cow::Borrowed("z")),
@@ -319,17 +315,13 @@ pub async fn close_dispute_after_user_resolution(
             ]);
 
             match new_dispute_event(my_keys, "", dispute_id.to_string(), tags) {
-                Ok(event) => match get_nostr_client() {
-                    Ok(client) => {
-                        tracing::info!("Publishing dispute close event: {:#?}", event);
-                        if let Err(e) = client.send_event(&event).await {
-                            tracing::error!("Failed to publish dispute close event: {}", e);
-                        }
+                Ok(event) => {
+                    let client = ctx.nostr_client();
+                    tracing::info!("Publishing dispute close event: {:#?}", event);
+                    if let Err(e) = client.send_event(&event).await {
+                        tracing::error!("Failed to publish dispute close event: {}", e);
                     }
-                    Err(e) => {
-                        tracing::error!("Failed to get Nostr client for dispute event: {}", e);
-                    }
-                },
+                }
                 Err(e) => {
                     tracing::error!(
                         "Failed to create dispute close event for dispute {}: {}",

src/app/order.rs

@@ -1,5 +1,4 @@
 use crate::app::context::AppContext;
-use crate::config::settings::Settings;
 use crate::db::update_user_trade_index;
 use crate::util::{get_bitcoin_price, publish_order, validate_invoice};
 use mostro_core::prelude::*;
@@ -8,11 +7,12 @@ use nostr_sdk::prelude::*;
 use nostr_sdk::Keys;
 
 async fn calculate_and_check_quote(
+    ctx: &AppContext,
     order: &SmallOrder,
     fiat_amount: &i64,
 ) -> Result<(), MostroError> {
     // Get mostro settings
-    let mostro_settings = Settings::get_mostro();
+    let mostro_settings = &ctx.settings().mostro;
     // Calculate quote
     let quote = match order.amount {
         0 => match get_bitcoin_price(&order.fiat_code) {
@@ -92,7 +92,7 @@ pub async fn order_action(
         let _invoice = validate_invoice(&msg, &Order::from(order.clone())).await?;
 
         // Check if fiat currency is accepted
-        let mostro_settings = Settings::get_mostro();
+        let mostro_settings = &ctx.settings().mostro;
         if let Err(cause) = order.check_fiat_currency(&mostro_settings.fiat_currencies_accepted) {
             return Err(MostroCantDo(cause));
         }
@@ -112,7 +112,7 @@ pub async fn order_action(
 
         // Check quote in sats for each amount
         for fiat_amount in amount_vec.iter() {
-            calculate_and_check_quote(order, fiat_amount).await?;
+            calculate_and_check_quote(ctx, order, fiat_amount).await?;
         }
 
         let trade_index = match msg.get_inner_message_kind().trade_index {

src/app/orders.rs

@@ -1,5 +1,4 @@
 use crate::app::context::AppContext;
-use crate::config::settings::Settings;
 use crate::util::{enqueue_order_msg, get_user_orders_by_id};
 use mostro_core::prelude::*;
 use nostr_sdk::prelude::*;
@@ -24,7 +23,7 @@ pub async fn orders_action(
         return Err(MostroCantDo(CantDoReason::InvalidParameters));
     }
 
-    let mostro_settings = Settings::get_mostro();
+    let mostro_settings = &ctx.settings().mostro;
     if ids.len() > mostro_settings.max_orders_per_response as usize {
         return Err(MostroCantDo(CantDoReason::TooManyRequests));
     }