cli

order.rs (73901B)

---

 use std::path::PathBuf;
 
 use serde::Serialize;
 use serde_json::{Value, json};
 
 use crate::cli::global::{
     OrderAppRecordExportArgs, OrderCancelArgs, OrderDecisionArg, OrderDecisionArgs,
     OrderRebindArgs, OrderRevisionDecisionArg, OrderRevisionDecisionArgs, OrderRevisionProposeArgs,
     OrderStatusArgs, OrderSubmitArgs, RecordLookupArgs,
 };
 use crate::ops::{
     OperationAdapterError, OperationRequest, OperationRequestData, OperationRequestPayload,
     OperationResult, OperationResultData, OperationService, OrderAcceptRequest, OrderAcceptResult,
     OrderAppExportRequest, OrderAppExportResult, OrderAppListRequest, OrderAppListResult,
     OrderCancelRequest, OrderCancelResult, OrderDeclineRequest, OrderDeclineResult,
     OrderEventListRequest, OrderEventListResult, OrderEventWatchRequest, OrderEventWatchResult,
     OrderGetRequest, OrderGetResult, OrderListRequest, OrderListResult, OrderRebindRequest,
     OrderRebindResult, OrderRevisionAcceptRequest, OrderRevisionAcceptResult,
     OrderRevisionDeclineRequest, OrderRevisionDeclineResult, OrderRevisionProposeRequest,
     OrderRevisionProposeResult, OrderStatusGetRequest, OrderStatusGetResult, OrderSubmitRequest,
     OrderSubmitResult,
 };
 use crate::runtime::RuntimeError;
 use crate::runtime::config::RuntimeConfig;
 use crate::view::runtime::{
     CommandDisposition, OrderAppRecordExportView, OrderCancellationView, OrderDecisionView,
     OrderRebindView, OrderRevisionDecisionView, OrderRevisionProposalView, OrderStatusView,
     OrderSubmitView,
 };
 
 const ORDER_EVENT_WATCH_DEFERRED_REASON: &str = "relay-backed order event watch is not implemented";
 
 pub struct OrderOperationService<'a> {
     config: &'a RuntimeConfig,
 }
 
 impl<'a> OrderOperationService<'a> {
     pub fn new(config: &'a RuntimeConfig) -> Self {
         Self { config }
     }
 }
 
 impl OperationService<OrderSubmitRequest> for OrderOperationService<'_> {
     type Result = OrderSubmitResult;
 
     fn execute(
         &self,
         request: OperationRequest<OrderSubmitRequest>,
     ) -> Result<OperationResult<Self::Result>, OperationAdapterError> {
         if request.context.requires_approval_token() {
             return Err(OperationAdapterError::approval_required(
                 request.operation_id(),
             ));
         }
 
         let key = required_order_key(&request)?;
         let args = OrderSubmitArgs {
             key,
             idempotency_key: request
                 .context
                 .idempotency_key
                 .clone()
                 .or_else(|| string_input(&request, "idempotency_key")),
         };
         let mut config = self.config.clone();
         if request.context.dry_run {
             config.output.dry_run = true;
         }
         let view = crate::runtime::order::submit(&config, &args).map_err(|error| {
             OperationAdapterError::sdk_adapter_failure(request.operation_id(), error)
         })?;
         submit_result::<OrderSubmitResult>(request.operation_id(), &view)
     }
 }
 
 impl OperationService<OrderGetRequest> for OrderOperationService<'_> {
     type Result = OrderGetResult;
 
     fn execute(
         &self,
         request: OperationRequest<OrderGetRequest>,
     ) -> Result<OperationResult<Self::Result>, OperationAdapterError> {
         let args = RecordLookupArgs {
             key: required_order_key(&request)?,
         };
         let view = map_runtime(crate::runtime::order::get(self.config, &args))?;
         serialized_target_result::<OrderGetResult, _>(&view)
     }
 }
 
 impl OperationService<OrderListRequest> for OrderOperationService<'_> {
     type Result = OrderListResult;
 
     fn execute(
         &self,
         _request: OperationRequest<OrderListRequest>,
     ) -> Result<OperationResult<Self::Result>, OperationAdapterError> {
         let view = map_runtime(crate::runtime::order::list(self.config))?;
         serialized_target_result::<OrderListResult, _>(&view)
     }
 }
 
 impl OperationService<OrderAppListRequest> for OrderOperationService<'_> {
     type Result = OrderAppListResult;
 
     fn execute(
         &self,
         _request: OperationRequest<OrderAppListRequest>,
     ) -> Result<OperationResult<Self::Result>, OperationAdapterError> {
         let view = map_runtime(crate::runtime::order::app_record_list(self.config))?;
         serialized_target_result::<OrderAppListResult, _>(&view)
     }
 }
 
 impl OperationService<OrderAppExportRequest> for OrderOperationService<'_> {
     type Result = OrderAppExportResult;
 
     fn execute(
         &self,
         request: OperationRequest<OrderAppExportRequest>,
     ) -> Result<OperationResult<Self::Result>, OperationAdapterError> {
         let args = OrderAppRecordExportArgs {
             record_id: required_string_input(&request, "record_id")?,
             output: optional_path_input(&request, "output"),
         };
         let mut config = self.config.clone();
         if request.context.dry_run {
             config.output.dry_run = true;
         }
         let view = crate::runtime::order::app_record_export(&config, &args).map_err(|error| {
             OperationAdapterError::runtime_failure(request.operation_id(), error)
         })?;
         order_app_record_export_result::<OrderAppExportResult>(request.operation_id(), &view)
     }
 }
 
 impl OperationService<OrderRebindRequest> for OrderOperationService<'_> {
     type Result = OrderRebindResult;
 
     fn execute(
         &self,
         request: OperationRequest<OrderRebindRequest>,
     ) -> Result<OperationResult<Self::Result>, OperationAdapterError> {
         let args = OrderRebindArgs {
             key: required_order_key(&request)?,
             selector: required_string_input(&request, "selector")?,
         };
         if request.context.dry_run {
             let view =
                 crate::runtime::order::rebind_preflight(self.config, &args).map_err(|error| {
                     OperationAdapterError::runtime_failure(request.operation_id(), error)
                 })?;
             return order_rebind_result::<OrderRebindResult>(request.operation_id(), &view);
         }
         if request.context.requires_approval_token() {
             return Err(OperationAdapterError::approval_required(
                 request.operation_id(),
             ));
         }
 
         let view = crate::runtime::order::rebind(self.config, &args).map_err(|error| {
             OperationAdapterError::runtime_failure(request.operation_id(), error)
         })?;
         order_rebind_result::<OrderRebindResult>(request.operation_id(), &view)
     }
 }
 
 impl OperationService<OrderAcceptRequest> for OrderOperationService<'_> {
     type Result = OrderAcceptResult;
 
     fn execute(
         &self,
         request: OperationRequest<OrderAcceptRequest>,
     ) -> Result<OperationResult<Self::Result>, OperationAdapterError> {
         if request.context.requires_approval_token() {
             return Err(OperationAdapterError::approval_required(
                 request.operation_id(),
             ));
         }
 
         let args = OrderDecisionArgs {
             key: required_order_key(&request)?,
             decision: OrderDecisionArg::Accept,
             reason: None,
             idempotency_key: request
                 .context
                 .idempotency_key
                 .clone()
                 .or_else(|| string_input(&request, "idempotency_key")),
         };
         let mut config = self.config.clone();
         if request.context.dry_run {
             config.output.dry_run = true;
         }
         let view = crate::runtime::order::decide(&config, &args).map_err(|error| {
             OperationAdapterError::runtime_failure(request.operation_id(), error)
         })?;
         decision_result::<OrderAcceptResult>(request.operation_id(), &view)
     }
 }
 
 impl OperationService<OrderDeclineRequest> for OrderOperationService<'_> {
     type Result = OrderDeclineResult;
 
     fn execute(
         &self,
         request: OperationRequest<OrderDeclineRequest>,
     ) -> Result<OperationResult<Self::Result>, OperationAdapterError> {
         let reason = string_input(&request, "reason")
             .map(|reason| reason.trim().to_owned())
             .filter(|reason| !reason.is_empty())
             .ok_or_else(|| {
                 invalid_input(
                     request.operation_id(),
                     "missing required `reason` input".to_owned(),
                 )
             })?;
         if request.context.requires_approval_token() {
             return Err(OperationAdapterError::approval_required(
                 request.operation_id(),
             ));
         }
 
         let args = OrderDecisionArgs {
             key: required_order_key(&request)?,
             decision: OrderDecisionArg::Decline,
             reason: Some(reason),
             idempotency_key: request
                 .context
                 .idempotency_key
                 .clone()
                 .or_else(|| string_input(&request, "idempotency_key")),
         };
         let mut config = self.config.clone();
         if request.context.dry_run {
             config.output.dry_run = true;
         }
         let view = crate::runtime::order::decide(&config, &args).map_err(|error| {
             OperationAdapterError::runtime_failure(request.operation_id(), error)
         })?;
         decision_result::<OrderDeclineResult>(request.operation_id(), &view)
     }
 }
 
 impl OperationService<OrderCancelRequest> for OrderOperationService<'_> {
     type Result = OrderCancelResult;
 
     fn execute(
         &self,
         request: OperationRequest<OrderCancelRequest>,
     ) -> Result<OperationResult<Self::Result>, OperationAdapterError> {
         let reason = string_input(&request, "reason")
             .map(|reason| reason.trim().to_owned())
             .filter(|reason| !reason.is_empty())
             .ok_or_else(|| {
                 invalid_input(
                     request.operation_id(),
                     "missing required `reason` input".to_owned(),
                 )
             })?;
         if request.context.requires_approval_token() {
             return Err(OperationAdapterError::approval_required(
                 request.operation_id(),
             ));
         }
 
         let args = OrderCancelArgs {
             key: required_order_key(&request)?,
             reason,
             idempotency_key: request
                 .context
                 .idempotency_key
                 .clone()
                 .or_else(|| string_input(&request, "idempotency_key")),
         };
         let mut config = self.config.clone();
         if request.context.dry_run {
             config.output.dry_run = true;
         }
         let view = crate::runtime::order::cancel(&config, &args).map_err(|error| {
             OperationAdapterError::runtime_failure(request.operation_id(), error)
         })?;
         cancellation_result::<OrderCancelResult>(request.operation_id(), &view)
     }
 }
 
 impl OperationService<OrderRevisionProposeRequest> for OrderOperationService<'_> {
     type Result = OrderRevisionProposeResult;
 
     fn execute(
         &self,
         request: OperationRequest<OrderRevisionProposeRequest>,
     ) -> Result<OperationResult<Self::Result>, OperationAdapterError> {
         let reason = string_input(&request, "reason")
             .map(|reason| reason.trim().to_owned())
             .filter(|reason| !reason.is_empty())
             .ok_or_else(|| {
                 invalid_input(
                     request.operation_id(),
                     "missing required `reason` input".to_owned(),
                 )
             })?;
         if request.context.requires_approval_token() {
             return Err(OperationAdapterError::approval_required(
                 request.operation_id(),
             ));
         }
 
         let args = OrderRevisionProposeArgs {
             key: required_order_key(&request)?,
             reason,
             bin_id: string_input(&request, "bin_id"),
             bin_count: u32_input(&request, "bin_count"),
             adjustment_id: string_input(&request, "adjustment_id"),
             adjustment_effect: string_input(&request, "adjustment_effect"),
             adjustment_amount: string_input(&request, "adjustment_amount"),
             adjustment_currency: string_input(&request, "adjustment_currency"),
             adjustment_reason: string_input(&request, "adjustment_reason"),
             idempotency_key: request
                 .context
                 .idempotency_key
                 .clone()
                 .or_else(|| string_input(&request, "idempotency_key")),
         };
         let mut config = self.config.clone();
         if request.context.dry_run {
             config.output.dry_run = true;
         }
         let view = crate::runtime::order::revision_propose(&config, &args).map_err(|error| {
             OperationAdapterError::runtime_failure(request.operation_id(), error)
         })?;
         revision_proposal_result::<OrderRevisionProposeResult>(request.operation_id(), &view)
     }
 }
 
 impl OperationService<OrderRevisionAcceptRequest> for OrderOperationService<'_> {
     type Result = OrderRevisionAcceptResult;
 
     fn execute(
         &self,
         request: OperationRequest<OrderRevisionAcceptRequest>,
     ) -> Result<OperationResult<Self::Result>, OperationAdapterError> {
         let args = OrderRevisionDecisionArgs {
             key: required_order_key(&request)?,
             revision_id: required_string_input(&request, "revision_id")?,
             decision: OrderRevisionDecisionArg::Accept,
             reason: None,
             idempotency_key: request
                 .context
                 .idempotency_key
                 .clone()
                 .or_else(|| string_input(&request, "idempotency_key")),
         };
         if request.context.requires_approval_token() {
             return Err(OperationAdapterError::approval_required(
                 request.operation_id(),
             ));
         }
 
         let mut config = self.config.clone();
         if request.context.dry_run {
             config.output.dry_run = true;
         }
         let view = crate::runtime::order::revision_decide(&config, &args).map_err(|error| {
             OperationAdapterError::runtime_failure(request.operation_id(), error)
         })?;
         revision_decision_result::<OrderRevisionAcceptResult>(request.operation_id(), &view)
     }
 }
 
 impl OperationService<OrderRevisionDeclineRequest> for OrderOperationService<'_> {
     type Result = OrderRevisionDeclineResult;
 
     fn execute(
         &self,
         request: OperationRequest<OrderRevisionDeclineRequest>,
     ) -> Result<OperationResult<Self::Result>, OperationAdapterError> {
         let reason = string_input(&request, "reason")
             .map(|reason| reason.trim().to_owned())
             .filter(|reason| !reason.is_empty())
             .ok_or_else(|| {
                 invalid_input(
                     request.operation_id(),
                     "missing required `reason` input".to_owned(),
                 )
             })?;
         let args = OrderRevisionDecisionArgs {
             key: required_order_key(&request)?,
             revision_id: required_string_input(&request, "revision_id")?,
             decision: OrderRevisionDecisionArg::Decline,
             reason: Some(reason),
             idempotency_key: request
                 .context
                 .idempotency_key
                 .clone()
                 .or_else(|| string_input(&request, "idempotency_key")),
         };
         if request.context.requires_approval_token() {
             return Err(OperationAdapterError::approval_required(
                 request.operation_id(),
             ));
         }
 
         let mut config = self.config.clone();
         if request.context.dry_run {
             config.output.dry_run = true;
         }
         let view = crate::runtime::order::revision_decide(&config, &args).map_err(|error| {
             OperationAdapterError::runtime_failure(request.operation_id(), error)
         })?;
         revision_decision_result::<OrderRevisionDeclineResult>(request.operation_id(), &view)
     }
 }
 
 impl OperationService<OrderStatusGetRequest> for OrderOperationService<'_> {
     type Result = OrderStatusGetResult;
 
     fn execute(
         &self,
         request: OperationRequest<OrderStatusGetRequest>,
     ) -> Result<OperationResult<Self::Result>, OperationAdapterError> {
         let args = OrderStatusArgs {
             key: required_order_key(&request)?,
         };
         let view = crate::runtime::order::status(self.config, &args).map_err(|error| {
             OperationAdapterError::sdk_adapter_failure(request.operation_id(), error)
         })?;
         status_result::<OrderStatusGetResult>(request.operation_id(), &view)
     }
 }
 
 impl OperationService<OrderEventListRequest> for OrderOperationService<'_> {
     type Result = OrderEventListResult;
 
     fn execute(
         &self,
         request: OperationRequest<OrderEventListRequest>,
     ) -> Result<OperationResult<Self::Result>, OperationAdapterError> {
         let order_id = string_input(&request, "order_id");
         let view = crate::runtime::order::event_list(self.config, order_id.as_deref()).map_err(
             |error| OperationAdapterError::runtime_failure(request.operation_id(), error),
         )?;
         event_list_result::<OrderEventListResult>(request.operation_id(), &view)
     }
 }
 
 impl OperationService<OrderEventWatchRequest> for OrderOperationService<'_> {
     type Result = OrderEventWatchResult;
 
     fn execute(
         &self,
         request: OperationRequest<OrderEventWatchRequest>,
     ) -> Result<OperationResult<Self::Result>, OperationAdapterError> {
         let order_id = required_order_key(&request)?;
         let action = format!("radroots order status get {order_id}");
         Err(OperationAdapterError::not_implemented_with_detail(
             request.operation_id(),
             ORDER_EVENT_WATCH_DEFERRED_REASON.to_owned(),
             json!({
                 "state": "not_implemented",
                 "order_id": order_id,
                 "reason": ORDER_EVENT_WATCH_DEFERRED_REASON,
                 "actions": [action],
             }),
         ))
     }
 }
 
 fn decision_result<R>(
     operation_id: &str,
     view: &OrderDecisionView,
 ) -> Result<OperationResult<R>, OperationAdapterError>
 where
     R: OperationResultData,
 {
     match view.disposition() {
         CommandDisposition::Success => serialized_target_result::<R, _>(view),
         CommandDisposition::ValidationFailed => {
             let message = view.reason.clone().unwrap_or_else(|| {
                 format!(
                     "order decision failed validation with state `{}`",
                     view.state
                 )
             });
             Err(OperationAdapterError::validation_failed_with_detail(
                 operation_id,
                 message,
                 order_decision_error_detail(view),
             ))
         }
         disposition => {
             let message = view
                 .reason
                 .clone()
                 .unwrap_or_else(|| format!("order decision finished with state `{}`", view.state));
             if disposition == CommandDisposition::ExternalUnavailable {
                 let detail = order_decision_error_detail(view);
                 if !view.failed_relays.is_empty() && view.connected_relays.is_empty() {
                     Err(OperationAdapterError::network_unavailable_with_detail(
                         operation_id,
                         message,
                         detail,
                     ))
                 } else {
                     Err(OperationAdapterError::operation_unavailable_with_detail(
                         operation_id,
                         message,
                         detail,
                     ))
                 }
             } else if disposition == CommandDisposition::Unconfigured {
                 Err(OperationAdapterError::operation_unavailable_with_detail(
                     operation_id,
                     message,
                     order_decision_error_detail(view),
                 ))
             } else if disposition == CommandDisposition::NotFound {
                 Err(OperationAdapterError::not_found_with_detail(
                     operation_id,
                     message,
                     order_decision_error_detail(view),
                 ))
             } else {
                 Err(OperationAdapterError::from_command_disposition(
                     operation_id,
                     disposition,
                     message,
                 ))
             }
         }
     }
 }
 
 fn order_decision_error_detail(view: &OrderDecisionView) -> Value {
     json!({
         "state": &view.state,
         "order_id": &view.order_id,
         "listing_addr": &view.listing_addr,
         "listing_event_id": &view.listing_event_id,
         "request_event_id": &view.request_event_id,
         "root_event_id": &view.root_event_id,
         "prev_event_id": &view.prev_event_id,
         "event_id": &view.event_id,
         "event_kind": view.event_kind,
         "inventory": &view.inventory,
         "buyer_pubkey": &view.buyer_pubkey,
         "seller_pubkey": &view.seller_pubkey,
         "decision": &view.decision,
         "dry_run": view.dry_run,
         "target_relays": &view.target_relays,
         "connected_relays": &view.connected_relays,
         "acknowledged_relays": &view.acknowledged_relays,
         "failed_relays": &view.failed_relays,
         "fetched_count": view.fetched_count,
         "decoded_count": view.decoded_count,
         "skipped_count": view.skipped_count,
         "idempotency_key": &view.idempotency_key,
         "signer_mode": &view.signer_mode,
         "issues": &view.issues,
         "actions": &view.actions,
     })
 }
 
 fn cancellation_result<R>(
     operation_id: &str,
     view: &OrderCancellationView,
 ) -> Result<OperationResult<R>, OperationAdapterError>
 where
     R: OperationResultData,
 {
     match view.disposition() {
         CommandDisposition::Success => serialized_target_result::<R, _>(view),
         CommandDisposition::ValidationFailed => {
             let message = view.reason.clone().unwrap_or_else(|| {
                 format!("order cancel failed validation with state `{}`", view.state)
             });
             Err(OperationAdapterError::validation_failed_with_detail(
                 operation_id,
                 message,
                 order_cancellation_error_detail(view),
             ))
         }
         disposition => {
             let message = view
                 .reason
                 .clone()
                 .unwrap_or_else(|| format!("order cancel finished with state `{}`", view.state));
             if disposition == CommandDisposition::ExternalUnavailable {
                 let detail = order_cancellation_error_detail(view);
                 if !view.failed_relays.is_empty() && view.connected_relays.is_empty() {
                     Err(OperationAdapterError::network_unavailable_with_detail(
                         operation_id,
                         message,
                         detail,
                     ))
                 } else {
                     Err(OperationAdapterError::operation_unavailable_with_detail(
                         operation_id,
                         message,
                         detail,
                     ))
                 }
             } else if disposition == CommandDisposition::Unconfigured {
                 Err(OperationAdapterError::operation_unavailable_with_detail(
                     operation_id,
                     message,
                     order_cancellation_error_detail(view),
                 ))
             } else {
                 Err(OperationAdapterError::from_command_disposition(
                     operation_id,
                     disposition,
                     message,
                 ))
             }
         }
     }
 }
 
 fn order_cancellation_error_detail(view: &OrderCancellationView) -> Value {
     json!({
         "state": &view.state,
         "order_id": &view.order_id,
         "listing_addr": &view.listing_addr,
         "request_event_id": &view.request_event_id,
         "decision_event_id": &view.decision_event_id,
         "root_event_id": &view.root_event_id,
         "prev_event_id": &view.prev_event_id,
         "event_id": &view.event_id,
         "event_kind": view.event_kind,
         "buyer_pubkey": &view.buyer_pubkey,
         "seller_pubkey": &view.seller_pubkey,
         "cancellation_reason": &view.cancellation_reason,
         "dry_run": view.dry_run,
         "target_relays": &view.target_relays,
         "connected_relays": &view.connected_relays,
         "acknowledged_relays": &view.acknowledged_relays,
         "failed_relays": &view.failed_relays,
         "fetched_count": view.fetched_count,
         "decoded_count": view.decoded_count,
         "skipped_count": view.skipped_count,
         "idempotency_key": &view.idempotency_key,
         "signer_mode": &view.signer_mode,
         "issues": &view.issues,
         "actions": &view.actions,
     })
 }
 
 fn revision_proposal_result<R>(
     operation_id: &str,
     view: &OrderRevisionProposalView,
 ) -> Result<OperationResult<R>, OperationAdapterError>
 where
     R: OperationResultData,
 {
     match view.disposition() {
         CommandDisposition::Success => serialized_target_result::<R, _>(view),
         CommandDisposition::ValidationFailed => {
             let message = view.reason.clone().unwrap_or_else(|| {
                 format!(
                     "order revision propose failed validation with state `{}`",
                     view.state
                 )
             });
             Err(OperationAdapterError::validation_failed_with_detail(
                 operation_id,
                 message,
                 order_revision_proposal_error_detail(view),
             ))
         }
         disposition => {
             let message = view.reason.clone().unwrap_or_else(|| {
                 format!(
                     "order revision propose finished with state `{}`",
                     view.state
                 )
             });
             if disposition == CommandDisposition::ExternalUnavailable {
                 let detail = order_revision_proposal_error_detail(view);
                 if !view.failed_relays.is_empty() && view.connected_relays.is_empty() {
                     Err(OperationAdapterError::network_unavailable_with_detail(
                         operation_id,
                         message,
                         detail,
                     ))
                 } else {
                     Err(OperationAdapterError::operation_unavailable_with_detail(
                         operation_id,
                         message,
                         detail,
                     ))
                 }
             } else if disposition == CommandDisposition::Unconfigured {
                 Err(OperationAdapterError::operation_unavailable_with_detail(
                     operation_id,
                     message,
                     order_revision_proposal_error_detail(view),
                 ))
             } else {
                 Err(OperationAdapterError::from_command_disposition(
                     operation_id,
                     disposition,
                     message,
                 ))
             }
         }
     }
 }
 
 fn order_revision_proposal_error_detail(view: &OrderRevisionProposalView) -> Value {
     json!({
         "state": &view.state,
         "order_id": &view.order_id,
         "revision_id": &view.revision_id,
         "listing_addr": &view.listing_addr,
         "request_event_id": &view.request_event_id,
         "decision_event_id": &view.decision_event_id,
         "root_event_id": &view.root_event_id,
         "prev_event_id": &view.prev_event_id,
         "event_id": &view.event_id,
         "event_kind": view.event_kind,
         "items": &view.items,
         "economics": &view.economics,
         "inventory": &view.inventory,
         "buyer_pubkey": &view.buyer_pubkey,
         "seller_pubkey": &view.seller_pubkey,
         "dry_run": view.dry_run,
         "target_relays": &view.target_relays,
         "connected_relays": &view.connected_relays,
         "acknowledged_relays": &view.acknowledged_relays,
         "failed_relays": &view.failed_relays,
         "fetched_count": view.fetched_count,
         "decoded_count": view.decoded_count,
         "skipped_count": view.skipped_count,
         "idempotency_key": &view.idempotency_key,
         "signer_mode": &view.signer_mode,
         "issues": &view.issues,
         "actions": &view.actions,
     })
 }
 
 fn revision_decision_result<R>(
     operation_id: &str,
     view: &OrderRevisionDecisionView,
 ) -> Result<OperationResult<R>, OperationAdapterError>
 where
     R: OperationResultData,
 {
     match view.disposition() {
         CommandDisposition::Success => serialized_target_result::<R, _>(view),
         CommandDisposition::ValidationFailed => {
             let message = view.reason.clone().unwrap_or_else(|| {
                 format!(
                     "order revision {} failed validation with state `{}`",
                     view.decision.as_deref().unwrap_or("decision"),
                     view.state
                 )
             });
             Err(OperationAdapterError::validation_failed_with_detail(
                 operation_id,
                 message,
                 order_revision_decision_error_detail(view),
             ))
         }
         disposition => {
             let message = view.reason.clone().unwrap_or_else(|| {
                 format!(
                     "order revision {} finished with state `{}`",
                     view.decision.as_deref().unwrap_or("decision"),
                     view.state
                 )
             });
             if disposition == CommandDisposition::ExternalUnavailable {
                 let detail = order_revision_decision_error_detail(view);
                 if !view.failed_relays.is_empty() && view.connected_relays.is_empty() {
                     Err(OperationAdapterError::network_unavailable_with_detail(
                         operation_id,
                         message,
                         detail,
                     ))
                 } else {
                     Err(OperationAdapterError::operation_unavailable_with_detail(
                         operation_id,
                         message,
                         detail,
                     ))
                 }
             } else if disposition == CommandDisposition::Unconfigured {
                 Err(OperationAdapterError::operation_unavailable_with_detail(
                     operation_id,
                     message,
                     order_revision_decision_error_detail(view),
                 ))
             } else {
                 Err(OperationAdapterError::from_command_disposition(
                     operation_id,
                     disposition,
                     message,
                 ))
             }
         }
     }
 }
 
 fn order_revision_decision_error_detail(view: &OrderRevisionDecisionView) -> Value {
     json!({
         "state": &view.state,
         "order_id": &view.order_id,
         "revision_id": &view.revision_id,
         "decision": &view.decision,
         "listing_addr": &view.listing_addr,
         "request_event_id": &view.request_event_id,
         "decision_event_id": &view.decision_event_id,
         "agreement_event_id": &view.agreement_event_id,
         "root_event_id": &view.root_event_id,
         "prev_event_id": &view.prev_event_id,
         "event_id": &view.event_id,
         "event_kind": view.event_kind,
         "economics": &view.economics,
         "inventory": &view.inventory,
         "buyer_pubkey": &view.buyer_pubkey,
         "seller_pubkey": &view.seller_pubkey,
         "dry_run": view.dry_run,
         "target_relays": &view.target_relays,
         "connected_relays": &view.connected_relays,
         "acknowledged_relays": &view.acknowledged_relays,
         "failed_relays": &view.failed_relays,
         "fetched_count": view.fetched_count,
         "decoded_count": view.decoded_count,
         "skipped_count": view.skipped_count,
         "idempotency_key": &view.idempotency_key,
         "signer_mode": &view.signer_mode,
         "issues": &view.issues,
         "actions": &view.actions,
     })
 }
 
 fn status_result<R>(
     operation_id: &str,
     view: &OrderStatusView,
 ) -> Result<OperationResult<R>, OperationAdapterError>
 where
     R: OperationResultData,
 {
     match view.disposition() {
         CommandDisposition::Success => serialized_target_result::<R, _>(view),
         disposition => {
             let message = view
                 .reason
                 .clone()
                 .unwrap_or_else(|| format!("order status finished with state `{}`", view.state));
             if disposition == CommandDisposition::ExternalUnavailable {
                 let detail = order_status_error_detail(view);
                 if !view.failed_relays.is_empty() && view.connected_relays.is_empty() {
                     Err(OperationAdapterError::network_unavailable_with_detail(
                         operation_id,
                         message,
                         detail,
                     ))
                 } else {
                     Err(OperationAdapterError::operation_unavailable_with_detail(
                         operation_id,
                         message,
                         detail,
                     ))
                 }
             } else if disposition == CommandDisposition::Unconfigured {
                 Err(OperationAdapterError::operation_unavailable_with_detail(
                     operation_id,
                     message,
                     order_status_error_detail(view),
                 ))
             } else {
                 Err(OperationAdapterError::from_command_disposition(
                     operation_id,
                     disposition,
                     message,
                 ))
             }
         }
     }
 }
 
 fn order_status_error_detail(view: &OrderStatusView) -> Value {
     json!({
         "state": &view.state,
         "order_id": &view.order_id,
         "request_event_id": &view.request_event_id,
         "decision_event_id": &view.decision_event_id,
         "agreement_event_id": &view.agreement_event_id,
         "listing_event_id": &view.listing_event_id,
         "listing_addr": &view.listing_addr,
         "buyer_pubkey": &view.buyer_pubkey,
         "seller_pubkey": &view.seller_pubkey,
         "last_event_id": &view.last_event_id,
         "revision": &view.revision,
         "inventory": &view.inventory,
         "lifecycle": &view.lifecycle,
         "reducer_issues": &view.reducer_issues,
         "target_relays": &view.target_relays,
         "connected_relays": &view.connected_relays,
         "failed_relays": &view.failed_relays,
         "fetched_count": view.fetched_count,
         "decoded_count": view.decoded_count,
         "skipped_count": view.skipped_count,
         "actions": &view.actions,
     })
 }
 
 fn serialized_target_result<R, T>(value: &T) -> Result<OperationResult<R>, OperationAdapterError>
 where
     R: OperationResultData,
     T: Serialize,
 {
     OperationResult::new(R::from_serializable(value)?)
 }
 
 fn submit_result<R>(
     operation_id: &str,
     view: &OrderSubmitView,
 ) -> Result<OperationResult<R>, OperationAdapterError>
 where
     R: OperationResultData,
 {
     match view.disposition() {
         CommandDisposition::Success => serialized_target_result::<R, _>(view),
         disposition => {
             let message = view
                 .reason
                 .clone()
                 .unwrap_or_else(|| format!("order submit finished with state `{}`", view.state));
             let detail = order_submit_error_detail(view);
             match disposition {
                 CommandDisposition::NotFound => Err(OperationAdapterError::not_found_with_detail(
                     operation_id,
                     message,
                     detail,
                 )),
                 CommandDisposition::ValidationFailed => {
                     Err(OperationAdapterError::validation_failed_with_detail(
                         operation_id,
                         message,
                         detail,
                     ))
                 }
                 CommandDisposition::Unconfigured => {
                     Err(OperationAdapterError::operation_unavailable_with_detail(
                         operation_id,
                         message,
                         detail,
                     ))
                 }
                 CommandDisposition::ExternalUnavailable => {
                     if !view.failed_relays.is_empty() && view.connected_relays.is_empty() {
                         Err(OperationAdapterError::network_unavailable_with_detail(
                             operation_id,
                             message,
                             detail,
                         ))
                     } else {
                         Err(OperationAdapterError::operation_unavailable_with_detail(
                             operation_id,
                             message,
                             detail,
                         ))
                     }
                 }
                 _ => Err(OperationAdapterError::from_command_disposition(
                     operation_id,
                     disposition,
                     message,
                 )),
             }
         }
     }
 }
 
 fn order_app_record_export_result<R>(
     operation_id: &str,
     view: &OrderAppRecordExportView,
 ) -> Result<OperationResult<R>, OperationAdapterError>
 where
     R: OperationResultData,
 {
     match view.disposition() {
         CommandDisposition::Success => serialized_target_result::<R, _>(view),
         CommandDisposition::NotFound => Err(OperationAdapterError::not_found_with_detail(
             operation_id,
             view.reason.clone().unwrap_or_else(|| {
                 format!(
                     "app-authored local order record `{}` was not found",
                     view.record_id
                 )
             }),
             serde_json::to_value(view).unwrap_or(Value::Null),
         )),
         CommandDisposition::ValidationFailed => {
             Err(OperationAdapterError::validation_failed_with_detail(
                 operation_id,
                 view.reason.clone().unwrap_or_else(|| {
                     format!(
                         "app-authored local order record `{}` cannot be exported",
                         view.record_id
                     )
                 }),
                 serde_json::to_value(view).unwrap_or(Value::Null),
             ))
         }
         disposition => Err(OperationAdapterError::from_command_disposition(
             operation_id,
             disposition,
             view.reason.clone().unwrap_or_else(|| {
                 format!(
                     "app-authored local order record export finished with state `{}`",
                     view.state
                 )
             }),
         )),
     }
 }
 
 fn order_rebind_result<R>(
     operation_id: &str,
     view: &OrderRebindView,
 ) -> Result<OperationResult<R>, OperationAdapterError>
 where
     R: OperationResultData,
 {
     match view.disposition() {
         CommandDisposition::Success => serialized_target_result::<R, _>(view),
         CommandDisposition::NotFound => Err(OperationAdapterError::not_found_with_detail(
             operation_id,
             view.reason
                 .clone()
                 .unwrap_or_else(|| format!("order draft `{}` was not found", view.lookup)),
             order_rebind_error_detail(view),
         )),
         CommandDisposition::ValidationFailed => {
             Err(OperationAdapterError::validation_failed_with_detail(
                 operation_id,
                 view.reason.clone().unwrap_or_else(|| {
                     format!("order rebind finished with state `{}`", view.state)
                 }),
                 order_rebind_error_detail(view),
             ))
         }
         disposition => Err(OperationAdapterError::from_command_disposition(
             operation_id,
             disposition,
             view.reason
                 .clone()
                 .unwrap_or_else(|| format!("order rebind finished with state `{}`", view.state)),
         )),
     }
 }
 
 fn order_rebind_error_detail(view: &OrderRebindView) -> Value {
     json!({
         "state": &view.state,
         "source": &view.source,
         "lookup": &view.lookup,
         "file": &view.file,
         "dry_run": view.dry_run,
         "from_order_id": &view.from_order_id,
         "to_order_id": &view.to_order_id,
         "order_id_changed": view.order_id_changed,
         "from_buyer_account_id": &view.from_buyer_account_id,
         "from_buyer_pubkey": &view.from_buyer_pubkey,
         "from_buyer_actor_source": &view.from_buyer_actor_source,
         "to_buyer_account_id": &view.to_buyer_account_id,
         "to_buyer_pubkey": &view.to_buyer_pubkey,
         "to_buyer_actor_source": &view.to_buyer_actor_source,
         "buyer_pubkey_changed": view.buyer_pubkey_changed,
         "existing_request_check": &view.existing_request_check,
         "existing_request_event_ids": &view.existing_request_event_ids,
         "actions": &view.actions,
     })
 }
 
 fn order_submit_error_detail(view: &OrderSubmitView) -> Value {
     json!({
         "state": &view.state,
         "source": &view.source,
         "order_id": &view.order_id,
         "file": &view.file,
         "listing_lookup": &view.listing_lookup,
         "listing_addr": &view.listing_addr,
         "listing_event_id": &view.listing_event_id,
         "listing_relays": &view.listing_relays,
         "buyer_account_id": &view.buyer_account_id,
         "buyer_pubkey": &view.buyer_pubkey,
         "seller_pubkey": &view.seller_pubkey,
         "event_id": &view.event_id,
         "event_kind": view.event_kind,
         "dry_run": view.dry_run,
         "deduplicated": view.deduplicated,
         "target_relays": &view.target_relays,
         "connected_relays": &view.connected_relays,
         "acknowledged_relays": &view.acknowledged_relays,
         "failed_relays": &view.failed_relays,
         "idempotency_key": &view.idempotency_key,
         "signer_mode": &view.signer_mode,
         "issues": &view.issues,
         "actions": &view.actions,
     })
 }
 
 fn event_list_result<R>(
     operation_id: &str,
     view: &crate::view::runtime::OrderEventListView,
 ) -> Result<OperationResult<R>, OperationAdapterError>
 where
     R: OperationResultData,
 {
     match view.disposition() {
         CommandDisposition::Success => serialized_target_result::<R, _>(view),
         disposition => {
             let message = view.reason.clone().unwrap_or_else(|| {
                 format!("order event list finished with state `{}`", view.state)
             });
             if disposition == CommandDisposition::ExternalUnavailable {
                 let detail = order_event_list_error_detail(view);
                 Err(OperationAdapterError::network_unavailable_with_detail(
                     operation_id,
                     message,
                     detail,
                 ))
             } else if disposition == CommandDisposition::Unconfigured {
                 Err(OperationAdapterError::operation_unavailable_with_detail(
                     operation_id,
                     message,
                     order_event_list_error_detail(view),
                 ))
             } else {
                 Err(OperationAdapterError::from_command_disposition(
                     operation_id,
                     disposition,
                     message,
                 ))
             }
         }
     }
 }
 
 fn order_event_list_error_detail(view: &crate::view::runtime::OrderEventListView) -> Value {
     json!({
         "state": &view.state,
         "seller_pubkey": &view.seller_pubkey,
         "target_relays": &view.target_relays,
         "connected_relays": &view.connected_relays,
         "failed_relays": &view.failed_relays,
         "fetched_count": view.fetched_count,
         "decoded_count": view.decoded_count,
         "skipped_count": view.skipped_count,
         "count": view.count,
         "actions": &view.actions,
     })
 }
 
 fn required_order_key<P>(request: &OperationRequest<P>) -> Result<String, OperationAdapterError>
 where
     P: OperationRequestPayload + OperationRequestData,
 {
     string_input(request, "order_id")
         .or_else(|| string_input(request, "key"))
         .ok_or_else(|| {
             invalid_input(
                 request.operation_id(),
                 "missing required `order_id` input".to_owned(),
             )
         })
 }
 
 fn required_string_input<P>(
     request: &OperationRequest<P>,
     key: &str,
 ) -> Result<String, OperationAdapterError>
 where
     P: OperationRequestPayload + OperationRequestData,
 {
     string_input(request, key)
         .map(|value| value.trim().to_owned())
         .filter(|value| !value.is_empty())
         .ok_or_else(|| {
             invalid_input(
                 request.operation_id(),
                 format!("missing required `{key}` input"),
             )
         })
 }
 
 fn string_input<P>(request: &OperationRequest<P>, key: &str) -> Option<String>
 where
     P: OperationRequestPayload + OperationRequestData,
 {
     request
         .payload
         .input()
         .get(key)
         .and_then(Value::as_str)
         .map(str::to_owned)
 }
 
 fn optional_path_input<P>(request: &OperationRequest<P>, key: &str) -> Option<PathBuf>
 where
     P: OperationRequestPayload + OperationRequestData,
 {
     string_input(request, key).map(PathBuf::from)
 }
 
 fn bool_input<P>(request: &OperationRequest<P>, key: &str) -> Option<bool>
 where
     P: OperationRequestPayload + OperationRequestData,
 {
     request.payload.input().get(key).and_then(Value::as_bool)
 }
 
 fn u32_input<P>(request: &OperationRequest<P>, key: &str) -> Option<u32>
 where
     P: OperationRequestPayload + OperationRequestData,
 {
     request
         .payload
         .input()
         .get(key)
         .and_then(Value::as_u64)
         .and_then(|value| u32::try_from(value).ok())
 }
 
 fn map_runtime<T>(result: Result<T, RuntimeError>) -> Result<T, OperationAdapterError> {
     result.map_err(|error| OperationAdapterError::Runtime(error.to_string()))
 }
 
 fn invalid_input(operation_id: &str, message: String) -> OperationAdapterError {
     OperationAdapterError::InvalidInput {
         operation_id: operation_id.to_owned(),
         message,
     }
 }
 
 #[cfg(test)]
 mod tests {
     use std::path::{Path, PathBuf};
 
     use radroots_runtime_paths::RadrootsMigrationReport;
     use radroots_secret_vault::RadrootsSecretBackend;
     use serde_json::{Map, Value};
     use tempfile::tempdir;
 
     use super::{OrderOperationService, decision_result};
     use crate::ops::{
         OperationAdapter, OperationContext, OperationData, OperationRequest, OrderAcceptRequest,
         OrderAcceptResult, OrderCancelRequest, OrderDeclineRequest, OrderDeclineResult,
         OrderEventListRequest, OrderEventWatchRequest, OrderGetRequest, OrderListRequest,
         OrderRevisionAcceptRequest, OrderRevisionDeclineRequest, OrderRevisionProposeRequest,
         OrderStatusGetRequest, OrderSubmitRequest,
     };
     use crate::runtime::config::{
         AccountConfig, AccountSecretContractConfig, HyfConfig, IdentityConfig, InteractionConfig,
         LocalConfig, LoggingConfig, MigrationConfig, MycConfig, OutputConfig, OutputFormat,
         PathsConfig, PublishConfig, PublishTransport, PublishTransportSource, RelayConfig,
         RelayConfigSource, RelayPublishPolicy, RpcConfig, RuntimeConfig, SignerBackend,
         SignerConfig, Verbosity,
     };
     use crate::view::runtime::OrderDecisionView;
 
     #[test]
     fn order_service_get_and_list_preserve_order_truth() {
         let dir = tempdir().expect("tempdir");
         let config = sample_config(dir.path());
         let service = OperationAdapter::new(OrderOperationService::new(&config));
         let get = OperationRequest::new(
             OperationContext::default(),
             OrderGetRequest::from_data(data(&[("order_id", "ord_missing")])),
         )
         .expect("order get request");
         let get_envelope = service
             .execute(get)
             .expect("order get result")
             .to_envelope(OperationContext::default().envelope_context("req_order_get"))
             .expect("order get envelope");
 
         assert_eq!(get_envelope.operation_id, "order.get");
         assert_eq!(get_envelope.result["state"], "missing");
         assert_eq!(get_envelope.result["actions"][0], "radroots order list");
         assert_eq!(get_envelope.result["actions"][1], "radroots basket create");
 
         let list = OperationRequest::new(OperationContext::default(), OrderListRequest::default())
             .expect("order list request");
         let list_envelope = service
             .execute(list)
             .expect("order list result")
             .to_envelope(OperationContext::default().envelope_context("req_order_list"))
             .expect("order list envelope");
         assert_eq!(list_envelope.operation_id, "order.list");
         assert_eq!(list_envelope.result["state"], "empty");
         assert_eq!(list_envelope.result["actions"][0], "radroots basket create");
     }
 
     #[test]
     fn order_submit_requires_approval_token() {
         let dir = tempdir().expect("tempdir");
         let config = sample_config(dir.path());
         let service = OperationAdapter::new(OrderOperationService::new(&config));
         let submit = OperationRequest::new(
             OperationContext::default(),
             OrderSubmitRequest::from_data(data(&[("order_id", "ord_missing")])),
         )
         .expect("order submit request");
         let error = service.execute(submit).expect_err("approval required");
 
         assert!(format!("{error}").contains("approval_token"));
         assert_eq!(error.to_output_error().code, "approval_required");
         assert_eq!(error.to_output_error().exit_code, 6);
     }
 
     #[test]
     fn order_submit_with_approval_returns_not_found_for_missing_order() {
         let dir = tempdir().expect("tempdir");
         let config = sample_config(dir.path());
         let service = OperationAdapter::new(OrderOperationService::new(&config));
         let mut context = OperationContext::default();
         context.approval_token = Some("approve_test".to_owned());
         let submit = OperationRequest::new(
             context.clone(),
             OrderSubmitRequest::from_data(data(&[("order_id", "ord_missing")])),
         )
         .expect("order submit request");
         let error = service.execute(submit).expect_err("missing order error");
         let output_error = error.to_output_error();
 
         assert_eq!(output_error.code, "not_found");
         assert_eq!(output_error.exit_code, 4);
         assert!(output_error.message.contains("ord_missing"));
         let envelope = crate::out::envelope::OutputEnvelope::failure(
             "order.submit",
             output_error,
             context.envelope_context("req_order_submit"),
         );
         let detail = envelope.errors[0].detail.as_ref().expect("submit detail");
         assert_eq!(detail["state"], "missing");
         assert_eq!(detail["order_id"], "ord_missing");
         assert_eq!(detail["actions"][0], "radroots order list");
         assert_eq!(detail["actions"][1], "radroots basket create");
         assert_eq!(
             envelope.next_actions[0].command.as_deref(),
             Some("radroots order list")
         );
         assert_eq!(
             envelope.next_actions[1].command.as_deref(),
             Some("radroots basket create")
         );
     }
 
     #[test]
     fn order_accept_requires_approval_token() {
         let dir = tempdir().expect("tempdir");
         let config = sample_config(dir.path());
         let service = OperationAdapter::new(OrderOperationService::new(&config));
         let accept = OperationRequest::new(
             OperationContext::default(),
             OrderAcceptRequest::from_data(data(&[("order_id", "ord_pending")])),
         )
         .expect("order accept request");
         let error = service.execute(accept).expect_err("approval required");
 
         assert_eq!(error.to_output_error().code, "approval_required");
     }
 
     #[test]
     fn order_accept_unconfigured_preserves_decision_detail() {
         let dir = tempdir().expect("tempdir");
         let config = sample_config(dir.path());
         let service = OperationAdapter::new(OrderOperationService::new(&config));
         let mut context = OperationContext::default();
         context.dry_run = true;
         let accept = OperationRequest::new(
             context,
             OrderAcceptRequest::from_data(data(&[("order_id", "ord_pending")])),
         )
         .expect("order accept request");
         let error = service
             .execute(accept)
             .expect_err("order accept unconfigured");
         let output_error = error.to_output_error();
         let detail = output_error.detail.as_ref().expect("decision detail");
 
         assert_eq!(output_error.code, "operation_unavailable");
         assert_eq!(detail["state"], "unconfigured");
         assert_eq!(detail["order_id"], "ord_pending");
         assert_eq!(detail["decision"], "accepted");
         assert!(detail["target_relays"].as_array().unwrap().is_empty());
     }
 
     #[test]
     fn order_decision_already_decided_maps_to_validation_failure() {
         let view = already_decided_view();
         let error = match decision_result::<OrderAcceptResult>("order.accept", &view) {
             Ok(_) => panic!("already decided view should fail validation"),
             Err(error) => error,
         };
         let output_error = error.to_output_error();
 
         assert_eq!(output_error.code, "validation_failed");
         assert_eq!(output_error.exit_code, 10);
         let detail = output_error.detail.expect("validation detail");
         assert_eq!(detail["state"], "already_decided");
         assert_eq!(detail["operation_id"], "order.accept");
         assert_eq!(detail["listing_event_id"], "l".repeat(64));
         assert_eq!(detail["event_id"], "d".repeat(64));
         assert_eq!(detail["event_kind"], 3423);
         assert_eq!(detail["idempotency_key"], "idem_test");
         assert_eq!(detail["signer_mode"], "local");
         assert_eq!(detail["actions"][0], "radroots order status get ord_test");
     }
 
     #[test]
     fn order_decision_invalid_maps_to_validation_failure() {
         let view = invalid_decision_view();
         let error = match decision_result::<OrderDeclineResult>("order.decline", &view) {
             Ok(_) => panic!("invalid view should fail validation"),
             Err(error) => error,
         };
         let output_error = error.to_output_error();
 
         assert_eq!(output_error.code, "validation_failed");
         assert_eq!(output_error.exit_code, 10);
         assert_eq!(
             output_error.message,
             "active order events for `ord_test` failed reducer validation"
         );
         let detail = output_error.detail.expect("validation detail");
         assert_eq!(detail["state"], "invalid");
         assert_eq!(detail["operation_id"], "order.decline");
         assert_eq!(detail["listing_event_id"], "l".repeat(64));
         assert_eq!(detail["event_id"], Value::Null);
         assert_eq!(detail["event_kind"], Value::Null);
         assert_eq!(detail["idempotency_key"], "idem_test");
         assert_eq!(detail["signer_mode"], "local");
     }
 
     #[test]
     fn order_decline_requires_reason_before_approval() {
         let dir = tempdir().expect("tempdir");
         let config = sample_config(dir.path());
         let service = OperationAdapter::new(OrderOperationService::new(&config));
         let decline = OperationRequest::new(
             OperationContext::default(),
             OrderDeclineRequest::from_data(data(&[("order_id", "ord_pending")])),
         )
         .expect("order decline request");
         let error = service.execute(decline).expect_err("reason required");
         let output_error = error.to_output_error();
 
         assert_eq!(output_error.code, "invalid_input");
         assert!(output_error.message.contains("reason"));
     }
 
     #[test]
     fn order_decline_rejects_blank_reason_before_approval() {
         let dir = tempdir().expect("tempdir");
         let config = sample_config(dir.path());
         let service = OperationAdapter::new(OrderOperationService::new(&config));
         let decline = OperationRequest::new(
             OperationContext::default(),
             OrderDeclineRequest::from_data(data(&[("order_id", "ord_pending"), ("reason", " ")])),
         )
         .expect("order decline request");
         let error = service.execute(decline).expect_err("reason required");
         let output_error = error.to_output_error();
 
         assert_eq!(output_error.code, "invalid_input");
         assert!(output_error.message.contains("reason"));
     }
 
     #[test]
     fn order_cancel_requires_reason_before_approval() {
         let dir = tempdir().expect("tempdir");
         let config = sample_config(dir.path());
         let service = OperationAdapter::new(OrderOperationService::new(&config));
         let cancel = OperationRequest::new(
             OperationContext::default(),
             OrderCancelRequest::from_data(data(&[("order_id", "ord_pending")])),
         )
         .expect("order cancel request");
         let error = service.execute(cancel).expect_err("reason required");
         let output_error = error.to_output_error();
 
         assert_eq!(output_error.code, "invalid_input");
         assert!(output_error.message.contains("reason"));
     }
 
     #[test]
     fn order_cancel_requires_approval_token() {
         let dir = tempdir().expect("tempdir");
         let config = sample_config(dir.path());
         let service = OperationAdapter::new(OrderOperationService::new(&config));
         let cancel = OperationRequest::new(
             OperationContext::default(),
             OrderCancelRequest::from_data(data(&[
                 ("order_id", "ord_pending"),
                 ("reason", "changed plans"),
             ])),
         )
         .expect("order cancel request");
         let error = service.execute(cancel).expect_err("approval required");
 
         assert_eq!(error.to_output_error().code, "approval_required");
     }
 
     #[test]
     fn order_revision_propose_requires_reason_before_approval() {
         let dir = tempdir().expect("tempdir");
         let config = sample_config(dir.path());
         let service = OperationAdapter::new(OrderOperationService::new(&config));
         let revision = OperationRequest::new(
             OperationContext::default(),
             OrderRevisionProposeRequest::from_data(data(&[("order_id", "ord_pending")])),
         )
         .expect("order revision request");
         let error = service.execute(revision).expect_err("reason required");
         let output_error = error.to_output_error();
 
         assert_eq!(output_error.code, "invalid_input");
         assert!(output_error.message.contains("reason"));
     }
 
     #[test]
     fn order_revision_propose_requires_approval_token() {
         let dir = tempdir().expect("tempdir");
         let config = sample_config(dir.path());
         let service = OperationAdapter::new(OrderOperationService::new(&config));
         let mut input = data(&[
             ("order_id", "ord_pending"),
             ("reason", "update count"),
             ("bin_id", "bin-1"),
         ]);
         input.insert("bin_count".to_owned(), Value::from(3));
         let revision = OperationRequest::new(
             OperationContext::default(),
             OrderRevisionProposeRequest::from_data(input),
         )
         .expect("order revision request");
         let error = service.execute(revision).expect_err("approval required");
 
         assert_eq!(error.to_output_error().code, "approval_required");
     }
 
     #[test]
     fn order_revision_accept_requires_approval_token() {
         let dir = tempdir().expect("tempdir");
         let config = sample_config(dir.path());
         let service = OperationAdapter::new(OrderOperationService::new(&config));
         let revision = OperationRequest::new(
             OperationContext::default(),
             OrderRevisionAcceptRequest::from_data(data(&[
                 ("order_id", "ord_pending"),
                 ("revision_id", "rev_pending"),
             ])),
         )
         .expect("order revision accept request");
         let error = service.execute(revision).expect_err("approval required");
 
         assert_eq!(error.to_output_error().code, "approval_required");
     }
 
     #[test]
     fn order_revision_decline_requires_reason_before_approval() {
         let dir = tempdir().expect("tempdir");
         let config = sample_config(dir.path());
         let service = OperationAdapter::new(OrderOperationService::new(&config));
         let revision = OperationRequest::new(
             OperationContext::default(),
             OrderRevisionDeclineRequest::from_data(data(&[
                 ("order_id", "ord_pending"),
                 ("revision_id", "rev_pending"),
             ])),
         )
         .expect("order revision decline request");
         let error = service.execute(revision).expect_err("reason required");
         let output_error = error.to_output_error();
 
         assert_eq!(output_error.code, "invalid_input");
         assert!(output_error.message.contains("reason"));
     }
 
     #[test]
     fn order_revision_decline_requires_approval_token() {
         let dir = tempdir().expect("tempdir");
         let config = sample_config(dir.path());
         let service = OperationAdapter::new(OrderOperationService::new(&config));
         let revision = OperationRequest::new(
             OperationContext::default(),
             OrderRevisionDeclineRequest::from_data(data(&[
                 ("order_id", "ord_pending"),
                 ("revision_id", "rev_pending"),
                 ("reason", "keep original order"),
             ])),
         )
         .expect("order revision decline request");
         let error = service.execute(revision).expect_err("approval required");
 
         assert_eq!(error.to_output_error().code, "approval_required");
     }
 
     #[test]
     fn order_status_get_uses_local_sdk_projection_without_relay() {
         let dir = tempdir().expect("tempdir");
         let config = sample_config(dir.path());
         let service = OperationAdapter::new(OrderOperationService::new(&config));
         let status = OperationRequest::new(
             OperationContext::default(),
             OrderStatusGetRequest::from_data(data(&[("order_id", "ord_pending")])),
         )
         .expect("order status request");
         let envelope = service
             .execute(status)
             .expect("status result")
             .to_envelope(OperationContext::default().envelope_context("req_order_status"))
             .expect("status envelope");
 
         assert_eq!(envelope.operation_id, "order.status.get");
         assert_eq!(envelope.result["state"], "missing");
         assert_eq!(envelope.result["source"], "SDK local order projection");
         assert_eq!(
             envelope.result["actor_context_source"],
             "sdk_local_projection"
         );
         assert_eq!(envelope.result["order_id"], "ord_pending");
         assert_eq!(envelope.result["fetched_count"], 0);
         assert_eq!(envelope.result["decoded_count"], 0);
         assert_eq!(envelope.result["skipped_count"], 0);
         assert!(envelope.next_actions.is_empty());
     }
 
     #[test]
     fn order_event_list_requires_relay_configuration() {
         let dir = tempdir().expect("tempdir");
         let config = sample_config(dir.path());
         let service = OperationAdapter::new(OrderOperationService::new(&config));
         let context = OperationContext::default();
         let request = OperationRequest::new(context.clone(), OrderEventListRequest::default())
             .expect("order event list request");
         let output_error = service
             .execute(request)
             .expect_err("order event list unconfigured")
             .to_output_error();
         let envelope = crate::out::envelope::OutputEnvelope::failure(
             "order.event.list",
             output_error,
             context.envelope_context("req_order_event_list"),
         );
 
         assert_eq!(envelope.errors[0].code, "operation_unavailable");
         assert_eq!(envelope.errors[0].exit_code, 3);
         assert!(envelope.errors[0].message.contains("configured relay"));
         assert_eq!(
             envelope.errors[0].detail.as_ref().unwrap()["actions"][0],
             "radroots --relay wss://relay.example.com order event list"
         );
         assert_eq!(
             envelope.next_actions[0].command.as_deref(),
             Some("radroots --relay wss://relay.example.com order event list")
         );
     }
 
     #[test]
     fn order_event_list_requires_seller_account_with_account_action() {
         let dir = tempdir().expect("tempdir");
         let mut config = sample_config(dir.path());
         config.relay.urls = vec!["ws://127.0.0.1:9".to_owned()];
         let service = OperationAdapter::new(OrderOperationService::new(&config));
         let context = OperationContext::default();
         let request = OperationRequest::new(context.clone(), OrderEventListRequest::default())
             .expect("order event list request");
         let output_error = service
             .execute(request)
             .expect_err("order event list missing account")
             .to_output_error();
         let envelope = crate::out::envelope::OutputEnvelope::failure(
             "order.event.list",
             output_error,
             context.envelope_context("req_order_event_list"),
         );
 
         assert_eq!(envelope.errors[0].code, "operation_unavailable");
         assert!(
             envelope.errors[0]
                 .message
                 .contains("selected seller account")
         );
         assert_eq!(
             envelope.errors[0].detail.as_ref().unwrap()["actions"][0],
             "radroots account create"
         );
         assert_eq!(
             envelope.next_actions[0].command.as_deref(),
             Some("radroots account create")
         );
     }
 
     #[test]
     fn order_event_watch_returns_deferred_error_with_target_action() {
         let dir = tempdir().expect("tempdir");
         let config = sample_config(dir.path());
         let service = OperationAdapter::new(OrderOperationService::new(&config));
         let request = OperationRequest::new(
             OperationContext::default(),
             OrderEventWatchRequest::from_data(data(&[("order_id", "ord_missing")])),
         )
         .expect("order event watch request");
         let error = service
             .execute(request)
             .expect_err("order event watch deferred");
         let envelope = crate::out::envelope::OutputEnvelope::failure(
             "order.event.watch",
             error.to_output_error(),
             OperationContext::default().envelope_context("req_order_watch"),
         );
 
         assert_eq!(envelope.operation_id, "order.event.watch");
         assert!(envelope.result.is_null());
         assert_eq!(envelope.errors[0].code, "not_implemented");
         assert_eq!(
             envelope.errors[0].detail.as_ref().unwrap()["state"],
             "not_implemented"
         );
         assert_eq!(
             envelope.errors[0].detail.as_ref().unwrap()["order_id"],
             "ord_missing"
         );
         assert_eq!(
             envelope.next_actions[0].command.as_deref(),
             Some("radroots order status get ord_missing")
         );
     }
 
     fn sample_config(root: &Path) -> RuntimeConfig {
         let data = root.join("data");
         let logs = root.join("logs");
         let secrets = root.join("secrets");
         RuntimeConfig {
             output: OutputConfig {
                 format: OutputFormat::Human,
                 verbosity: Verbosity::Normal,
                 color: true,
                 dry_run: false,
             },
             interaction: InteractionConfig {
                 input_enabled: true,
                 assume_yes: false,
                 stdin_tty: false,
                 stdout_tty: false,
                 prompts_allowed: false,
                 confirmations_allowed: false,
             },
             paths: PathsConfig {
                 profile: "interactive_user".into(),
                 profile_source: "test".into(),
                 allowed_profiles: vec!["interactive_user".into(), "repo_local".into()],
                 root_source: "test".into(),
                 repo_local_root: None,
                 repo_local_root_source: None,
                 subordinate_path_override_source: "runtime_config".into(),
                 app_namespace: "apps/cli".into(),
                 shared_accounts_namespace: "shared/accounts".into(),
                 shared_identities_namespace: "shared/identities".into(),
                 app_config_path: root.join("config/apps/cli/config.toml"),
                 workspace_config_path: None,
                 app_data_root: data.join("apps/cli"),
                 app_logs_root: logs.join("apps/cli"),
                 shared_accounts_data_root: data.join("shared/accounts"),
                 shared_accounts_secrets_root: secrets.join("shared/accounts"),
                 default_identity_path: secrets.join("shared/identities/default.json"),
             },
             migration: MigrationConfig {
                 report: RadrootsMigrationReport::empty(),
             },
             logging: LoggingConfig {
                 filter: "info".into(),
                 directory: None,
                 stdout: false,
             },
             account: AccountConfig {
                 selector: None,
                 store_path: data.join("shared/accounts/store.json"),
                 secrets_dir: secrets.join("shared/accounts"),
                 secret_backend: RadrootsSecretBackend::EncryptedFile,
                 secret_fallback: None,
             },
             account_secret_contract: AccountSecretContractConfig {
                 default_backend: "host_vault".into(),
                 default_fallback: Some("encrypted_file".into()),
                 allowed_backends: vec!["host_vault".into(), "encrypted_file".into()],
                 host_vault_policy: Some("desktop".into()),
                 uses_protected_store: true,
             },
             identity: IdentityConfig {
                 path: secrets.join("shared/identities/default.json"),
             },
             signer: SignerConfig {
                 backend: SignerBackend::Local,
             },
             publish: PublishConfig {
                 transport: PublishTransport::DirectNostrRelay,
                 source: PublishTransportSource::Defaults,
                 radrootsd_proxy: crate::runtime::config::RadrootsdProxyConfig::default(),
             },
             relay: RelayConfig {
                 urls: Vec::new(),
                 publish_policy: RelayPublishPolicy::Any,
                 source: RelayConfigSource::Defaults,
             },
             local: LocalConfig {
                 root: data.join("apps/cli/replica"),
                 replica_db_path: data.join("apps/cli/replica/replica.sqlite"),
                 backups_dir: data.join("apps/cli/replica/backups"),
                 exports_dir: data.join("apps/cli/replica/exports"),
             },
             myc: MycConfig {
                 executable: PathBuf::from("myc"),
                 status_timeout_ms: 2_000,
             },
             hyf: HyfConfig {
                 enabled: false,
                 executable: PathBuf::from("hyfd"),
             },
             rpc: RpcConfig {
                 url: "http://127.0.0.1:7070".into(),
             },
             rhi: crate::runtime::config::RhiConfig {
                 trusted_worker_pubkeys: Vec::new(),
             },
             capability_bindings: Vec::new(),
         }
     }
 
     fn data(entries: &[(&str, &str)]) -> OperationData {
         entries
             .iter()
             .map(|(key, value)| ((*key).to_owned(), Value::String((*value).to_owned())))
             .collect::<Map<String, Value>>()
     }
 
     fn already_decided_view() -> OrderDecisionView {
         OrderDecisionView {
             state: "already_decided".to_owned(),
             source: "test".to_owned(),
             order_id: "ord_test".to_owned(),
             listing_addr: Some("30402:seller:listing".to_owned()),
             buyer_pubkey: Some("b".repeat(64)),
             seller_pubkey: Some("s".repeat(64)),
             decision: "accepted".to_owned(),
             request_event_id: Some("r".repeat(64)),
             listing_event_id: Some("l".repeat(64)),
             root_event_id: Some("r".repeat(64)),
             prev_event_id: Some("r".repeat(64)),
             event_id: Some("d".repeat(64)),
             event_kind: Some(3423),
             inventory: None,
             dry_run: false,
             target_relays: vec!["ws://relay.test".to_owned()],
             connected_relays: vec!["ws://relay.test".to_owned()],
             acknowledged_relays: Vec::new(),
             failed_relays: Vec::new(),
             fetched_count: 2,
             decoded_count: 2,
             skipped_count: 0,
             idempotency_key: Some("idem_test".to_owned()),
             signer_mode: Some("local".to_owned()),
             reason: Some(
                 "order accept refused because order `ord_test` already has a visible `accepted` seller decision"
                     .to_owned(),
             ),
             issues: Vec::new(),
             actions: vec!["radroots order status get ord_test".to_owned()],
         }
     }
 
     fn invalid_decision_view() -> OrderDecisionView {
         let mut view = already_decided_view();
         view.state = "invalid".to_owned();
         view.decision = "declined".to_owned();
         view.event_id = None;
         view.event_kind = None;
         view.reason =
             Some("active order events for `ord_test` failed reducer validation".to_owned());
         view
     }
 }