mostro 0.17.5

Lightning Network peer-to-peer nostr platform
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

//! RPC server module for direct admin communication
//!
//! This module provides a gRPC server that allows direct communication with Mostro
//! for admin operations without going through the Nostr protocol. This is useful
//! for local development and admin applications that need low-latency access.

pub mod rate_limiter;
pub mod server;
pub mod service;

pub use server::RpcServer;

// Include the generated protobuf code
pub mod admin {
    tonic::include_proto!("mostro.admin.v1");
}

#[cfg(test)]
mod tests {
    use super::admin::*;

    #[test]
    fn test_protobuf_message_creation() {
        // Test that protobuf messages can be created correctly
        let cancel_request = CancelOrderRequest {
            order_id: "test-order".to_string(),
            request_id: Some("test-request".to_string()),
        };

        assert_eq!(cancel_request.order_id, "test-order");
        assert_eq!(cancel_request.request_id, Some("test-request".to_string()));

        let cancel_response = CancelOrderResponse {
            success: true,
            error_message: None,
        };

        assert!(cancel_response.success);
        assert!(cancel_response.error_message.is_none());
    }

    #[test]
    fn test_all_request_types() {
        // Test that all request types can be instantiated
        let _cancel_req = CancelOrderRequest {
            order_id: "order1".to_string(),
            request_id: None,
        };

        let _settle_req = SettleOrderRequest {
            order_id: "order2".to_string(),
            request_id: Some("req2".to_string()),
        };

        let _add_solver_req = AddSolverRequest {
            solver_pubkey: "npub1...".to_string(),
            request_id: None,
        };

        let _take_dispute_req = TakeDisputeRequest {
            dispute_id: "dispute1".to_string(),
            request_id: Some("req3".to_string()),
        };

        let _validate_password_req = ValidateDbPasswordRequest {
            password: "test-pass".to_string(),
        };

        // Test passes if all types can be instantiated (no panic)
    }

    #[test]
    fn test_all_response_types() {
        // Test that all response types can be instantiated
        let _cancel_resp = CancelOrderResponse {
            success: true,
            error_message: None,
        };

        let _settle_resp = SettleOrderResponse {
            success: false,
            error_message: Some("Error".to_string()),
        };

        let _add_solver_resp = AddSolverResponse {
            success: true,
            error_message: None,
        };

        let _take_dispute_resp = TakeDisputeResponse {
            success: false,
            error_message: Some("Dispute not found".to_string()),
        };

        let _validate_password_resp = ValidateDbPasswordResponse {
            success: true,
            error_message: None,
        };

        // Test passes if all types can be instantiated (no panic)
    }
}