@wlfi-agent/cli 1.4.16 → 1.4.18

package/crates/vault-cli-daemon/src/relay_sync.rs

@@ -828,18 +828,121 @@ fn format_time(value: OffsetDateTime) -> Result<String> {
 
 #[cfg(test)]
 mod tests {
-    use super::{approval_metadata, manual_approval_error_feedback, resolve_relay_daemon_token_with};
+    use super::{
+        action_name, apply_daemon_auth, approval_metadata, asset_token_address,
+        flatten_policy_records, format_time, manual_approval_error_feedback,
+        manual_approval_feedback, map_approval_status, normalize_secret, policy_metadata,
+        poll_updates, policy_name, process_update, register_snapshot, resolve_relay_daemon_token_with,
+        submit_feedback, ProcessedFeedback, RelayEncryptedPayload,
+        RelayEncryptedUpdateRecord,
+    };
     use std::collections::BTreeMap;
+    use std::collections::BTreeSet;
     use std::fs;
     use std::path::Path;
+    use std::sync::{Mutex, OnceLock};
     use std::time::{SystemTime, UNIX_EPOCH};
+    use chacha20poly1305::aead::Aead;
+    use chacha20poly1305::{KeyInit, XChaCha20Poly1305};
+    use reqwest::Client;
     use time::OffsetDateTime;
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+    use tokio::net::TcpListener;
+    use tokio::sync::oneshot;
     use uuid::Uuid;
-    use vault_daemon::DaemonError;
+    use vault_daemon::{DaemonConfig, DaemonError, InMemoryDaemon, RelayRegistrationSnapshot};
     use vault_domain::{
-        AgentAction, AssetId, ManualApprovalDecision, ManualApprovalRequest,
-        ManualApprovalStatus,
+        AgentAction, AgentKey, AssetId, BroadcastTx, Eip3009Transfer, EntityScope,
+        ManualApprovalDecision, ManualApprovalRequest, ManualApprovalStatus, Permit2Permit,
+        PolicyAttachment, PolicyType, RelayConfig, SpendingPolicy,
     };
+    use vault_signer::SoftwareSignerBackend;
+
+    fn env_lock() -> &'static Mutex<()> {
+        static ENV_LOCK: OnceLock<Mutex<()>> = OnceLock::new();
+        ENV_LOCK.get_or_init(|| Mutex::new(()))
+    }
+
+    #[derive(Debug)]
+    struct CapturedHttpRequest {
+        request_line: String,
+        headers: BTreeMap<String, String>,
+        body: String,
+    }
+
+    async fn spawn_single_response_server(
+        status_line: &str,
+        response_body: &str,
+    ) -> (
+        String,
+        oneshot::Receiver<CapturedHttpRequest>,
+        tokio::task::JoinHandle<()>,
+    ) {
+        let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind");
+        let addr = listener.local_addr().expect("addr");
+        let status_line = status_line.to_string();
+        let response_body = response_body.to_string();
+        let (tx, rx) = oneshot::channel();
+
+        let handle = tokio::spawn(async move {
+            let (mut stream, _) = listener.accept().await.expect("accept");
+            let mut buffer = Vec::new();
+            let header_end = loop {
+                let mut chunk = [0u8; 1024];
+                let read = stream.read(&mut chunk).await.expect("read request");
+                if read == 0 {
+                    panic!("connection closed before headers");
+                }
+                buffer.extend_from_slice(&chunk[..read]);
+                if let Some(position) = buffer.windows(4).position(|window| window == b"\r\n\r\n") {
+                    break position + 4;
+                }
+            };
+
+            let header_text = String::from_utf8_lossy(&buffer[..header_end]).to_string();
+            let mut lines = header_text.split("\r\n");
+            let request_line = lines.next().expect("request line").to_string();
+            let mut headers = BTreeMap::new();
+            let mut content_length = 0usize;
+            for line in lines.filter(|line| !line.is_empty()) {
+                let (name, value) = line.split_once(':').expect("header");
+                let value = value.trim().to_string();
+                if name.eq_ignore_ascii_case("content-length") {
+                    content_length = value.parse::<usize>().expect("content length");
+                }
+                headers.insert(name.to_ascii_lowercase(), value);
+            }
+
+            let mut body_bytes = buffer[header_end..].to_vec();
+            while body_bytes.len() < content_length {
+                let mut chunk = vec![0u8; content_length - body_bytes.len()];
+                let read = stream.read(&mut chunk).await.expect("read body");
+                if read == 0 {
+                    break;
+                }
+                body_bytes.extend_from_slice(&chunk[..read]);
+            }
+            let body = String::from_utf8(body_bytes[..content_length].to_vec()).expect("utf8 body");
+
+            let response = format!(
+                "HTTP/1.1 {status_line}\r\ncontent-type: application/json\r\ncontent-length: {}\r\nconnection: close\r\n\r\n{}",
+                response_body.len(),
+                response_body
+            );
+            stream
+                .write_all(response.as_bytes())
+                .await
+                .expect("write response");
+
+            let _ = tx.send(CapturedHttpRequest {
+                request_line,
+                headers,
+                body,
+            });
+        });
+
+        (format!("http://{}", addr), rx, handle)
+    }
 
     #[test]
     fn approval_metadata_includes_admin_reissue_token_and_public_hash_for_pending_requests() {
@@ -892,6 +995,113 @@ mod tests {
         ))
     }
 
+    fn sample_address(value: &str) -> vault_domain::EvmAddress {
+        value.parse().expect("address")
+    }
+
+    fn sample_policy(policy_type: PolicyType) -> SpendingPolicy {
+        SpendingPolicy::new(
+            1,
+            policy_type,
+            1_000,
+            EntityScope::All,
+            EntityScope::All,
+            EntityScope::All,
+        )
+        .expect("policy")
+    }
+
+    fn sample_manual_request(status: ManualApprovalStatus) -> ManualApprovalRequest {
+        ManualApprovalRequest {
+            id: Uuid::parse_str("aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa").expect("uuid"),
+            agent_key_id: Uuid::parse_str("bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb").expect("uuid"),
+            vault_key_id: Uuid::parse_str("cccccccc-cccc-4ccc-8ccc-cccccccccccc").expect("uuid"),
+            request_payload_hash_hex: "11".repeat(32),
+            action: AgentAction::TransferNative {
+                chain_id: 56,
+                to: sample_address("0x2222222222222222222222222222222222222222"),
+                amount_wei: 1,
+            },
+            chain_id: 56,
+            asset: AssetId::NativeEth,
+            recipient: sample_address("0x2222222222222222222222222222222222222222"),
+            amount_wei: 1,
+            created_at: OffsetDateTime::UNIX_EPOCH,
+            updated_at: OffsetDateTime::UNIX_EPOCH,
+            status,
+            triggered_by_policy_ids: vec![Uuid::nil()],
+            completed_at: None,
+            rejection_reason: None,
+        }
+    }
+
+    fn sample_snapshot(relay_url: &str) -> RelayRegistrationSnapshot {
+        RelayRegistrationSnapshot {
+            relay_config: RelayConfig {
+                relay_url: Some(relay_url.to_string()),
+                frontend_url: Some("https://frontend.example".to_string()),
+                daemon_id_hex: "aa".repeat(32),
+                daemon_public_key_hex: "bb".repeat(32),
+            },
+            relay_private_key_hex: "11".repeat(32),
+            vault_public_key_hex: Some("04".repeat(33)),
+            ethereum_address: Some("0x9999999999999999999999999999999999999999".to_string()),
+            policies: vec![sample_policy(PolicyType::PerTxMaxSpending)],
+            agent_keys: vec![AgentKey {
+                id: Uuid::parse_str("dddddddd-dddd-4ddd-8ddd-dddddddddddd").expect("uuid"),
+                vault_key_id: Uuid::parse_str("eeeeeeee-eeee-4eee-8eee-eeeeeeeeeeee").expect("uuid"),
+                policies: PolicyAttachment::AllPolicies,
+                created_at: OffsetDateTime::UNIX_EPOCH,
+            }],
+            manual_approval_requests: vec![sample_manual_request(ManualApprovalStatus::Pending)],
+        }
+    }
+
+    fn encrypt_payload(
+        daemon_public_key_hex: &str,
+        plaintext: &[u8],
+    ) -> RelayEncryptedPayload {
+        let public_bytes = hex::decode(daemon_public_key_hex).expect("decode daemon public key");
+        let peer_public = x25519_dalek::PublicKey::from(
+            <[u8; 32]>::try_from(public_bytes.as_slice()).expect("public key bytes"),
+        );
+        let secret = x25519_dalek::StaticSecret::from([7u8; 32]);
+        let shared_secret = secret.diffie_hellman(&peer_public);
+        let cipher = XChaCha20Poly1305::new(shared_secret.as_bytes().into());
+        let nonce = [9u8; 24];
+        let ciphertext = cipher
+            .encrypt(chacha20poly1305::XNonce::from_slice(&nonce), plaintext)
+            .expect("encrypt payload");
+
+        RelayEncryptedPayload {
+            algorithm: "x25519-xchacha20poly1305-v1".to_string(),
+            ciphertext_base64: hex::encode(ciphertext),
+            encapsulated_key_base64: hex::encode(x25519_dalek::PublicKey::from(&secret).as_bytes()),
+            nonce_base64: hex::encode(nonce),
+        }
+    }
+
+    fn sample_update_record(
+        daemon_id: &str,
+        payload: RelayEncryptedPayload,
+    ) -> RelayEncryptedUpdateRecord {
+        RelayEncryptedUpdateRecord {
+            claim_token: Some("claim-token".to_string()),
+            daemon_id: daemon_id.to_string(),
+            payload,
+            target_approval_request_id: None,
+            r#type: "manual_approval_decision".to_string(),
+            update_id: "update-1".to_string(),
+        }
+    }
+
+    fn test_runtime() -> tokio::runtime::Runtime {
+        tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .expect("runtime")
+    }
+
     #[test]
     fn resolve_relay_daemon_token_prefers_explicit_env_value() {
         let env = BTreeMap::from([
@@ -1011,4 +1221,566 @@ mod tests {
                 .is_some_and(|message| message.contains("already Rejected"))
         );
     }
+
+    #[test]
+    fn manual_approval_feedback_and_reject_error_feedback_cover_remaining_paths() {
+        let approval_request_id =
+            Uuid::parse_str("dddddddd-dddd-4ddd-8ddd-dddddddddddd").expect("uuid");
+
+        let feedback = manual_approval_feedback(
+            approval_request_id,
+            ManualApprovalStatus::Approved,
+            Some("   "),
+            "done".to_string(),
+        );
+        assert_eq!(feedback.status, "applied");
+        assert_eq!(feedback.message.as_deref(), Some("done"));
+        assert!(
+            !feedback
+                .details
+                .as_ref()
+                .expect("details")
+                .contains_key("note")
+        );
+
+        let reject_feedback = manual_approval_error_feedback(
+            approval_request_id,
+            ManualApprovalDecision::Reject,
+            Some("because"),
+            &DaemonError::Transport("boom".to_string()),
+        );
+        assert_eq!(reject_feedback.status, "rejected");
+        assert!(reject_feedback.details.is_none());
+        assert_eq!(reject_feedback.message.as_deref(), Some("transport error: boom"));
+    }
+
+    #[test]
+    fn normalize_secret_trims_and_rejects_blank_values() {
+        assert_eq!(normalize_secret("  token  ").as_deref(), Some("token"));
+        assert_eq!(normalize_secret("\n\t  "), None);
+    }
+
+    #[test]
+    fn policy_name_covers_all_policy_types() {
+        assert_eq!(
+            policy_name(&sample_policy(PolicyType::DailyMaxSpending)),
+            "daily_max_spending"
+        );
+        assert_eq!(
+            policy_name(&sample_policy(PolicyType::DailyMaxTxCount)),
+            "daily_max_tx_count"
+        );
+        assert_eq!(
+            policy_name(&sample_policy(PolicyType::WeeklyMaxSpending)),
+            "weekly_max_spending"
+        );
+        assert_eq!(
+            policy_name(&sample_policy(PolicyType::PerTxMaxSpending)),
+            "per_tx_max_spending"
+        );
+        assert_eq!(
+            policy_name(&sample_policy(PolicyType::PerTxMaxFeePerGas)),
+            "per_tx_max_fee_per_gas"
+        );
+        assert_eq!(
+            policy_name(&sample_policy(PolicyType::PerTxMaxPriorityFeePerGas)),
+            "per_tx_max_priority_fee_per_gas"
+        );
+        assert_eq!(
+            policy_name(&sample_policy(PolicyType::PerTxMaxCalldataBytes)),
+            "per_tx_max_calldata_bytes"
+        );
+        assert_eq!(
+            policy_name(&sample_policy(PolicyType::PerChainMaxGasSpend)),
+            "per_chain_max_gas_spend"
+        );
+        assert_eq!(
+            policy_name(&sample_policy(PolicyType::ManualApproval)),
+            "manual_approval"
+        );
+    }
+
+    #[test]
+    fn action_name_covers_all_agent_actions() {
+        assert_eq!(
+            action_name(&AgentAction::Approve {
+                chain_id: 1,
+                token: sample_address("0x1111111111111111111111111111111111111111"),
+                spender: sample_address("0x2222222222222222222222222222222222222222"),
+                amount_wei: 1,
+            }),
+            "approve"
+        );
+        assert_eq!(
+            action_name(&AgentAction::Transfer {
+                chain_id: 1,
+                token: sample_address("0x1111111111111111111111111111111111111111"),
+                to: sample_address("0x2222222222222222222222222222222222222222"),
+                amount_wei: 1,
+            }),
+            "transfer"
+        );
+        assert_eq!(
+            action_name(&AgentAction::TransferNative {
+                chain_id: 1,
+                to: sample_address("0x2222222222222222222222222222222222222222"),
+                amount_wei: 1,
+            }),
+            "transfer_native"
+        );
+        assert_eq!(
+            action_name(&AgentAction::Permit2Permit {
+                permit: Permit2Permit {
+                    chain_id: 1,
+                    permit2_contract: sample_address(
+                        "0x4444444444444444444444444444444444444444"
+                    ),
+                    token: sample_address("0x1111111111111111111111111111111111111111"),
+                    spender: sample_address("0x2222222222222222222222222222222222222222"),
+                    amount_wei: 1,
+                    expiration: 1,
+                    nonce: 1,
+                    sig_deadline: 1,
+                },
+            }),
+            "permit2_permit"
+        );
+        assert_eq!(
+            action_name(&AgentAction::Eip3009TransferWithAuthorization {
+                authorization: Eip3009Transfer {
+                    chain_id: 1,
+                    token: sample_address("0x1111111111111111111111111111111111111111"),
+                    token_name: "USD Coin".to_string(),
+                    token_version: Some("2".to_string()),
+                    from: sample_address("0x2222222222222222222222222222222222222222"),
+                    to: sample_address("0x3333333333333333333333333333333333333333"),
+                    amount_wei: 1,
+                    valid_after: 1,
+                    valid_before: 2,
+                    nonce_hex: format!("0x{}", "07".repeat(32)),
+                },
+            }),
+            "eip3009_transfer_with_authorization"
+        );
+        assert_eq!(
+            action_name(&AgentAction::Eip3009ReceiveWithAuthorization {
+                authorization: Eip3009Transfer {
+                    chain_id: 1,
+                    token: sample_address("0x1111111111111111111111111111111111111111"),
+                    token_name: "USD Coin".to_string(),
+                    token_version: None,
+                    from: sample_address("0x2222222222222222222222222222222222222222"),
+                    to: sample_address("0x3333333333333333333333333333333333333333"),
+                    amount_wei: 1,
+                    valid_after: 1,
+                    valid_before: 2,
+                    nonce_hex: format!("0x{}", "09".repeat(32)),
+                },
+            }),
+            "eip3009_receive_with_authorization"
+        );
+        assert_eq!(
+            action_name(&AgentAction::BroadcastTx {
+                tx: BroadcastTx {
+                    chain_id: 1,
+                    nonce: 1,
+                    to: sample_address("0x2222222222222222222222222222222222222222"),
+                    value_wei: 0,
+                    data_hex: "0x".to_string(),
+                    gas_limit: 21_000,
+                    max_fee_per_gas_wei: 2,
+                    max_priority_fee_per_gas_wei: 1,
+                    tx_type: 0x02,
+                    delegation_enabled: false,
+                },
+            }),
+            "broadcast_tx"
+        );
+    }
+
+    #[test]
+    fn map_approval_status_covers_all_statuses() {
+        assert_eq!(map_approval_status(ManualApprovalStatus::Pending), "pending");
+        assert_eq!(map_approval_status(ManualApprovalStatus::Approved), "approved");
+        assert_eq!(map_approval_status(ManualApprovalStatus::Rejected), "rejected");
+        assert_eq!(map_approval_status(ManualApprovalStatus::Completed), "completed");
+    }
+
+    #[test]
+    fn asset_token_address_covers_native_and_erc20_assets() {
+        assert_eq!(asset_token_address(&AssetId::NativeEth), None);
+        assert_eq!(
+            asset_token_address(&AssetId::Erc20(sample_address(
+                "0x1111111111111111111111111111111111111111"
+            )))
+            .as_deref(),
+            Some("0x1111111111111111111111111111111111111111")
+        );
+    }
+
+    #[test]
+    fn flatten_policy_records_expands_scopes_and_skips_disabled_policies() {
+        let mut policy = SpendingPolicy::new_manual_approval(
+            5,
+            10,
+            100,
+            EntityScope::Set(BTreeSet::from([
+                sample_address("0x1111111111111111111111111111111111111111"),
+                sample_address("0x2222222222222222222222222222222222222222"),
+            ])),
+            EntityScope::Set(BTreeSet::from([
+                AssetId::NativeEth,
+                AssetId::Erc20(sample_address("0x3333333333333333333333333333333333333333")),
+            ])),
+            EntityScope::Set(BTreeSet::from([1, 10])),
+        )
+        .expect("policy");
+        let mut disabled = sample_policy(PolicyType::PerTxMaxSpending);
+        disabled.enabled = false;
+        policy.id = Uuid::parse_str("aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa").expect("uuid");
+
+        let records = flatten_policy_records(&[policy.clone(), disabled], "2026-03-11T00:00:00Z");
+        assert_eq!(records.len(), 8);
+        assert!(records.iter().all(|record| record.policy_id == policy.id.to_string()));
+        assert!(records.iter().all(|record| record.requires_manual_approval));
+        assert!(records.iter().all(|record| record.scope == "override"));
+        assert!(records.iter().any(|record| record.token_address.is_none()));
+        assert!(records.iter().any(|record| {
+            record.token_address.as_deref()
+                == Some("0x3333333333333333333333333333333333333333")
+        }));
+        assert!(records.iter().all(|record| record.metadata.is_some()));
+    }
+
+    #[test]
+    fn policy_metadata_covers_scope_specific_fields() {
+        let policy = SpendingPolicy::new_manual_approval(
+            1,
+            10,
+            100,
+            EntityScope::Set(BTreeSet::from([sample_address(
+                "0x1111111111111111111111111111111111111111",
+            )])),
+            EntityScope::Set(BTreeSet::from([AssetId::Erc20(sample_address(
+                "0x3333333333333333333333333333333333333333",
+            ))])),
+            EntityScope::Set(BTreeSet::from([1])),
+        )
+        .expect("policy");
+
+        let metadata = policy_metadata(
+            &policy,
+            Some(&AssetId::Erc20(sample_address(
+                "0x3333333333333333333333333333333333333333",
+            ))),
+            Some(1),
+            "override",
+        );
+        assert_eq!(metadata.get("policyType").map(String::as_str), Some("manual_approval"));
+        assert_eq!(metadata.get("scope").map(String::as_str), Some("override"));
+        assert_eq!(metadata.get("recipientScope").map(String::as_str), Some("set"));
+        assert_eq!(metadata.get("assetScope").map(String::as_str), Some("set"));
+        assert_eq!(metadata.get("networkScope").map(String::as_str), Some("set"));
+        assert_eq!(metadata.get("asset").map(String::as_str), Some("erc20:0x3333333333333333333333333333333333333333"));
+        assert_eq!(metadata.get("chainId").map(String::as_str), Some("1"));
+    }
+
+    #[test]
+    fn approval_metadata_omits_capability_for_non_pending_requests() {
+        let mut request = ManualApprovalRequest {
+            id: Uuid::parse_str("cccccccc-cccc-4ccc-8ccc-cccccccccccc").expect("uuid"),
+            agent_key_id: Uuid::nil(),
+            vault_key_id: Uuid::nil(),
+            request_payload_hash_hex: "22".repeat(32),
+            action: AgentAction::TransferNative {
+                chain_id: 56,
+                to: sample_address("0x2222222222222222222222222222222222222222"),
+                amount_wei: 1,
+            },
+            chain_id: 56,
+            asset: AssetId::NativeEth,
+            recipient: sample_address("0x2222222222222222222222222222222222222222"),
+            amount_wei: 1,
+            created_at: OffsetDateTime::UNIX_EPOCH,
+            updated_at: OffsetDateTime::UNIX_EPOCH,
+            status: ManualApprovalStatus::Completed,
+            triggered_by_policy_ids: vec![Uuid::nil()],
+            completed_at: Some(OffsetDateTime::UNIX_EPOCH),
+            rejection_reason: None,
+        };
+
+        let metadata = approval_metadata(&request, &"11".repeat(32)).expect("metadata");
+        assert_eq!(
+            metadata.get("triggeredPolicyIds").map(String::as_str),
+            Some("00000000-0000-0000-0000-000000000000")
+        );
+        assert_eq!(metadata.get("asset").map(String::as_str), Some("native_eth"));
+        assert!(!metadata.contains_key("approvalCapabilityToken"));
+        assert!(!metadata.contains_key("approvalCapabilityHash"));
+
+        request.status = ManualApprovalStatus::Rejected;
+        let metadata = approval_metadata(&request, " ").expect("metadata");
+        assert!(!metadata.contains_key("approvalCapabilityToken"));
+    }
+
+    #[test]
+    fn format_time_renders_rfc3339() {
+        let rendered = format_time(OffsetDateTime::UNIX_EPOCH).expect("format time");
+        assert_eq!(rendered, "1970-01-01T00:00:00Z");
+    }
+
+    #[test]
+    fn apply_daemon_auth_adds_header_when_token_env_is_present() {
+        let _guard = env_lock().lock().expect("env lock");
+        std::env::set_var("WLFI_RELAY_DAEMON_TOKEN", "relay-secret");
+        std::env::remove_var("WLFI_RELAY_DAEMON_TOKEN_FILE");
+
+        let client = Client::new();
+        let request = apply_daemon_auth(client.get("https://relay.example"))
+            .build()
+            .expect("build request");
+        assert_eq!(
+            request
+                .headers()
+                .get("x-relay-daemon-token")
+                .and_then(|value| value.to_str().ok()),
+            Some("relay-secret")
+        );
+
+        std::env::remove_var("WLFI_RELAY_DAEMON_TOKEN");
+    }
+
+    #[tokio::test]
+    async fn register_snapshot_posts_expected_payload_and_header() {
+        let _guard = env_lock().lock().expect("env lock");
+        std::env::set_var("WLFI_RELAY_DAEMON_TOKEN", "relay-secret");
+        std::env::set_var("HOSTNAME", "daemon-host");
+
+        let (base_url, request_rx, handle) = spawn_single_response_server("200 OK", "{}").await;
+        let snapshot = sample_snapshot(&base_url);
+        let client = Client::new();
+
+        register_snapshot(
+            &client,
+            &base_url,
+            "software",
+            "2026-03-11T00:00:00Z",
+            &snapshot,
+            snapshot.ethereum_address.as_deref().expect("eth address"),
+        )
+        .await
+        .expect("register snapshot");
+
+        let captured = request_rx.await.expect("captured request");
+        handle.await.expect("server");
+        assert_eq!(captured.request_line, "POST /v1/daemon/register HTTP/1.1");
+        assert_eq!(
+            captured.headers.get("x-relay-daemon-token").map(String::as_str),
+            Some("relay-secret")
+        );
+        assert!(captured.body.contains("\"daemonId\":\""));
+        assert!(captured.body.contains("\"signerBackend\":\"software\""));
+        assert!(captured.body.contains("\"label\":\"daemon-host\""));
+        assert!(captured.body.contains("\"approvalRequests\""));
+
+        std::env::remove_var("WLFI_RELAY_DAEMON_TOKEN");
+        std::env::remove_var("HOSTNAME");
+    }
+
+    #[tokio::test]
+    async fn poll_updates_posts_expected_request_and_deserializes_response() {
+        let response_body = r#"{"items":[{"claimToken":"claim-token","daemonId":"daemon-1","payload":{"algorithm":"x25519-xchacha20poly1305-v1","ciphertextBase64":"aa","encapsulatedKeyBase64":"bb","nonceBase64":"cc"},"type":"manual_approval_decision","updateId":"update-1"}]}"#;
+        let (base_url, request_rx, handle) =
+            spawn_single_response_server("200 OK", &response_body).await;
+        let client = Client::new();
+
+        let response = poll_updates(&client, &base_url, "daemon-1")
+            .await
+            .expect("poll response");
+        let captured = request_rx.await.expect("captured request");
+        handle.await.expect("server");
+
+        assert_eq!(captured.request_line, "POST /v1/daemon/poll-updates HTTP/1.1");
+        assert!(captured.body.contains("\"daemonId\":\"daemon-1\""));
+        assert!(captured.body.contains("\"leaseSeconds\":30"));
+        assert!(captured.body.contains("\"limit\":25"));
+        assert_eq!(response.items.len(), 1);
+        assert_eq!(response.items[0].daemon_id, "daemon-1");
+    }
+
+    #[tokio::test]
+    async fn submit_feedback_posts_expected_payload() {
+        let (base_url, request_rx, handle) = spawn_single_response_server("200 OK", "{}").await;
+        let client = Client::new();
+
+        submit_feedback(
+            &client,
+            &base_url,
+            "claim-token",
+            "daemon-1",
+            "update-1",
+            ProcessedFeedback {
+                details: Some(BTreeMap::from([(
+                    "approvalRequestId".to_string(),
+                    "approval-1".to_string(),
+                )])),
+                message: Some("done".to_string()),
+                status: "applied",
+            },
+        )
+        .await
+        .expect("submit feedback");
+
+        let captured = request_rx.await.expect("captured request");
+        handle.await.expect("server");
+        assert_eq!(captured.request_line, "POST /v1/daemon/submit-feedback HTTP/1.1");
+        assert!(captured.body.contains("\"claimToken\":\"claim-token\""));
+        assert!(captured.body.contains("\"status\":\"applied\""));
+        assert!(captured.body.contains("\"approvalRequestId\":\"approval-1\""));
+    }
+
+    #[tokio::test]
+    async fn process_update_rejects_invalid_payload_variants() {
+        let daemon = InMemoryDaemon::new(
+            "vault-password",
+            SoftwareSignerBackend::default(),
+            DaemonConfig::default(),
+        )
+        .expect("daemon");
+        let snapshot = daemon
+            .relay_registration_snapshot()
+            .expect("relay snapshot");
+        let expected_daemon_id = snapshot.relay_config.daemon_id_hex.clone();
+
+        let mismatch = process_update(
+            &daemon,
+            &expected_daemon_id,
+            &RelayEncryptedUpdateRecord {
+                daemon_id: "wrong-daemon".to_string(),
+                ..sample_update_record(
+                    &expected_daemon_id,
+                    RelayEncryptedPayload {
+                        algorithm: "x25519-xchacha20poly1305-v1".to_string(),
+                        ciphertext_base64: String::new(),
+                        encapsulated_key_base64: String::new(),
+                        nonce_base64: String::new(),
+                    },
+                )
+            },
+        )
+        .await;
+        assert_eq!(mismatch.status, "rejected");
+        assert!(
+            mismatch
+                .message
+                .as_deref()
+                .is_some_and(|value| value.contains("does not match"))
+        );
+
+        let unsupported = process_update(
+            &daemon,
+            &expected_daemon_id,
+            &RelayEncryptedUpdateRecord {
+                r#type: "other".to_string(),
+                ..sample_update_record(
+                    &expected_daemon_id,
+                    RelayEncryptedPayload {
+                        algorithm: "x25519-xchacha20poly1305-v1".to_string(),
+                        ciphertext_base64: String::new(),
+                        encapsulated_key_base64: String::new(),
+                        nonce_base64: String::new(),
+                    },
+                )
+            },
+        )
+        .await;
+        assert_eq!(unsupported.status, "failed");
+        assert!(
+            unsupported
+                .message
+                .as_deref()
+                .is_some_and(|value| value.contains("unsupported relay update type"))
+        );
+
+        let invalid_json_payload = encrypt_payload(
+            &snapshot.relay_config.daemon_public_key_hex,
+            br#"{"not":"a manual approval payload"}"#,
+        );
+        let invalid_json = process_update(
+            &daemon,
+            &expected_daemon_id,
+            &sample_update_record(&expected_daemon_id, invalid_json_payload),
+        )
+        .await;
+        assert_eq!(invalid_json.status, "failed");
+        assert!(
+            invalid_json
+                .message
+                .as_deref()
+                .is_some_and(|value| value.contains("invalid relay update payload"))
+        );
+
+        let wrong_payload_daemon = encrypt_payload(
+            &snapshot.relay_config.daemon_public_key_hex,
+            &serde_json::to_vec(&serde_json::json!({
+                "approvalId": Uuid::nil().to_string(),
+                "daemonId": "wrong-daemon",
+                "decision": "approve",
+                "vaultPassword": "vault-password"
+            }))
+            .expect("json"),
+        );
+        let wrong_payload_daemon = process_update(
+            &daemon,
+            &expected_daemon_id,
+            &sample_update_record(&expected_daemon_id, wrong_payload_daemon),
+        )
+        .await;
+        assert_eq!(wrong_payload_daemon.status, "rejected");
+
+        let target_mismatch_payload = encrypt_payload(
+            &snapshot.relay_config.daemon_public_key_hex,
+            &serde_json::to_vec(&serde_json::json!({
+                "approvalId": Uuid::nil().to_string(),
+                "daemonId": expected_daemon_id,
+                "decision": "approve",
+                "vaultPassword": "vault-password"
+            }))
+            .expect("json"),
+        );
+        let target_mismatch = process_update(
+            &daemon,
+            &expected_daemon_id,
+            &RelayEncryptedUpdateRecord {
+                target_approval_request_id: Some(Uuid::new_v4().to_string()),
+                ..sample_update_record(&expected_daemon_id, target_mismatch_payload)
+            },
+        )
+        .await;
+        assert_eq!(target_mismatch.status, "rejected");
+
+        let invalid_approval_id_payload = encrypt_payload(
+            &snapshot.relay_config.daemon_public_key_hex,
+            &serde_json::to_vec(&serde_json::json!({
+                "approvalId": "not-a-uuid",
+                "daemonId": expected_daemon_id,
+                "decision": "approve",
+                "vaultPassword": "vault-password"
+            }))
+            .expect("json"),
+        );
+        let invalid_approval_id = process_update(
+            &daemon,
+            &expected_daemon_id,
+            &sample_update_record(&expected_daemon_id, invalid_approval_id_payload),
+        )
+        .await;
+        assert_eq!(invalid_approval_id.status, "failed");
+        assert!(
+            invalid_approval_id
+                .message
+                .as_deref()
+                .is_some_and(|value| value.contains("approval_id is not a UUID"))
+        );
+    }
 }