cli

commit f08c10945ffc172b13d2ee079b09b5c1d93589c4
parent 64c52fbc0a0eac0169f285ec508e46192069bcb6
Author: triesap <tyson@radroots.org>
Date:   Mon, 13 Apr 2026 15:00:03 +0000

order: route cli submit through radroots_sdk

Diffstat:
M
src/runtime/daemon.rs
 | 
91
+++++++++++++++++++++++++++++++++++++++++++++++++++++--------------------------

1 file changed, 61 insertions(+), 30 deletions(-)
diff --git a/src/runtime/daemon.rs b/src/runtime/daemon.rs
@@ -92,8 +92,6 @@ struct BridgeStatusRemote {
 struct BridgeJobRemote {
     job_id: String,
     command: String,
-    #[serde(default)]
-    idempotency_key: Option<String>,
     status: String,
     terminal: bool,
     recovered_after_restart: bool,
@@ -133,12 +131,6 @@ struct Nip46SessionRemote {
     signer_authority: Option<ActorWriteSignerAuthority>,
 }
 
-#[derive(Debug, Clone, Deserialize)]
-struct BridgePublishResponseRemote {
-    deduplicated: bool,
-    job: BridgeJobRemote,
-}
-
 #[derive(Debug, Clone)]
 pub struct BridgeListingPublishResult {
     pub deduplicated: bool,
@@ -431,28 +423,31 @@ pub fn bridge_order_request(
     signer_session_id: Option<&str>,
     signer_authority: Option<&ActorWriteSignerAuthority>,
 ) -> Result<BridgeOrderRequestResult, DaemonRpcError> {
-    let target = actor_write_target(config)?;
-    let response: BridgePublishResponseRemote = call(
-        &target,
-        "bridge.order.request",
-        Some(serde_json::json!({
-            "order": order,
-            "idempotency_key": idempotency_key,
-            "signer_session_id": signer_session_id,
-            "signer_authority": signer_authority,
-        })),
-        RpcAuthMode::BridgeBearer,
-    )?;
-    Ok(BridgeOrderRequestResult {
-        deduplicated: response.deduplicated,
-        job_id: response.job.job_id,
-        idempotency_key: response.job.idempotency_key,
-        status: response.job.status,
-        signer_mode: response.job.signer_mode,
-        signer_session_id: response.job.signer_session_id,
-        event_id: response.job.event_id,
-        event_addr: response.job.event_addr,
-    })
+    let Some(signer_session_id) = signer_session_id else {
+        return Err(DaemonRpcError::Unconfigured(
+            "order publish requires a signer session id".to_owned(),
+        ));
+    };
+
+    let sdk = actor_write_sdk_client(config)?;
+    let session = SdkRadrootsdSignerSessionRef::from_session_id(signer_session_id.to_owned());
+    let mut options = radroots_sdk::SdkRadrootsdOrderRequestPublishOptions::from_signer_session_ref(
+        &session,
+    );
+    if let Some(idempotency_key) = idempotency_key {
+        options = options.with_idempotency_key(idempotency_key.to_owned());
+    }
+    if let Some(signer_authority) = signer_authority {
+        options = options.with_signer_authority(sdk_signer_authority(signer_authority));
+    }
+
+    let receipt = block_on_sdk(
+        sdk.trade()
+            .publish_order_request_via_radrootsd_with_options(order, &options),
+    )?
+    .map_err(map_sdk_publish_error)?;
+
+    map_order_request_receipt(receipt, idempotency_key)
 }
 
 fn bridge_status(config: &RuntimeConfig) -> Result<BridgeStatusRemote, DaemonRpcError> {
@@ -580,6 +575,42 @@ fn map_listing_publish_receipt(
     })
 }
 
+fn map_order_request_receipt(
+    receipt: radroots_sdk::SdkPublishReceipt,
+    idempotency_key: Option<&str>,
+) -> Result<BridgeOrderRequestResult, DaemonRpcError> {
+    let radroots_sdk::SdkTransportReceipt::Radrootsd(transport_receipt) = receipt.transport_receipt else {
+        return Err(DaemonRpcError::InvalidResponse(
+            "sdk order publish returned a non-radrootsd transport receipt".to_owned(),
+        ));
+    };
+    let Some(job_id) = transport_receipt.job_id else {
+        return Err(DaemonRpcError::InvalidResponse(
+            "sdk order publish did not return a job id".to_owned(),
+        ));
+    };
+    let Some(status) = transport_receipt.status else {
+        return Err(DaemonRpcError::InvalidResponse(
+            "sdk order publish did not return a job status".to_owned(),
+        ));
+    };
+    let Some(signer_mode) = transport_receipt.signer_mode else {
+        return Err(DaemonRpcError::InvalidResponse(
+            "sdk order publish did not return a signer mode".to_owned(),
+        ));
+    };
+    Ok(BridgeOrderRequestResult {
+        deduplicated: transport_receipt.deduplicated,
+        job_id,
+        idempotency_key: idempotency_key.map(str::to_owned),
+        status,
+        signer_mode,
+        signer_session_id: transport_receipt.signer_session_id,
+        event_id: receipt.event_id,
+        event_addr: transport_receipt.event_addr,
+    })
+}
+
 fn block_on_sdk<F, T>(future: F) -> Result<T, DaemonRpcError>
 where
     F: std::future::Future<Output = T>,