lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README | LICENSE

model.rs (4555B)

      1 use alloc::vec::Vec;
      2 use base64::Engine as _;
      3 use base64::engine::general_purpose::{URL_SAFE, URL_SAFE_NO_PAD};
      4 use radroots_simplex_smp_crypto::prelude::{
      5     RadrootsSimplexOfficialX3dhParams, RadrootsSimplexSmpRatchetHeader,
      6 };
      7 use radroots_simplex_smp_proto::prelude::{
      8     RadrootsSimplexSmpQueueUri, RadrootsSimplexSmpServerAddress, RadrootsSimplexSmpVersionRange,
      9 };
     10 
     11 pub const RADROOTS_SIMPLEX_AGENT_CURRENT_VERSION: u16 = 5;
     12 pub type RadrootsSimplexAgentMessageId = u64;
     13 
     14 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
     15 pub enum RadrootsSimplexAgentConnectionMode {
     16     Direct,
     17     ContactAddress,
     18 }
     19 
     20 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
     21 pub enum RadrootsSimplexAgentConnectionStatus {
     22     CreatePending,
     23     InvitationReady,
     24     JoinPending,
     25     AwaitingApproval,
     26     Allowed,
     27     Connected,
     28     Suspended,
     29     Rotating,
     30     Deleted,
     31 }
     32 
     33 #[derive(Debug, Clone, PartialEq, Eq)]
     34 pub struct RadrootsSimplexAgentConnectionLink {
     35     pub invitation_queue: RadrootsSimplexSmpQueueUri,
     36     pub connection_id: Vec<u8>,
     37     pub e2e_ratchet_params: RadrootsSimplexOfficialX3dhParams,
     38     pub contact_address: bool,
     39 }
     40 
     41 #[derive(Debug, Clone, PartialEq, Eq)]
     42 pub struct RadrootsSimplexAgentQueueAddress {
     43     pub server: RadrootsSimplexSmpServerAddress,
     44     pub sender_id: Vec<u8>,
     45 }
     46 
     47 #[derive(Debug, Clone, PartialEq, Eq)]
     48 pub struct RadrootsSimplexAgentQueueDescriptor {
     49     pub queue_uri: RadrootsSimplexSmpQueueUri,
     50     pub replaced_queue: Option<RadrootsSimplexAgentQueueAddress>,
     51     pub primary: bool,
     52     pub sender_key: Option<Vec<u8>>,
     53 }
     54 
     55 impl RadrootsSimplexAgentQueueDescriptor {
     56     pub const fn client_version_range(&self) -> RadrootsSimplexSmpVersionRange {
     57         self.queue_uri.version_range
     58     }
     59 
     60     pub fn queue_address(&self) -> RadrootsSimplexAgentQueueAddress {
     61         RadrootsSimplexAgentQueueAddress {
     62             server: self.queue_uri.server.clone(),
     63             sender_id: decode_queue_uri_sender_id(&self.queue_uri.sender_id),
     64         }
     65     }
     66 }
     67 
     68 fn decode_queue_uri_sender_id(sender_id: &str) -> Vec<u8> {
     69     URL_SAFE_NO_PAD
     70         .decode(sender_id.as_bytes())
     71         .or_else(|_| URL_SAFE.decode(sender_id.as_bytes()))
     72         .expect("validated SimpleX queue URI sender id")
     73 }
     74 
     75 #[derive(Debug, Clone, PartialEq, Eq)]
     76 pub struct RadrootsSimplexAgentQueueUseDecision {
     77     pub queue_address: RadrootsSimplexAgentQueueAddress,
     78     pub primary: bool,
     79 }
     80 
     81 #[derive(Debug, Clone, PartialEq, Eq)]
     82 pub struct RadrootsSimplexAgentMessageHeader {
     83     pub message_id: RadrootsSimplexAgentMessageId,
     84     pub previous_message_hash: Vec<u8>,
     85 }
     86 
     87 #[derive(Debug, Clone, PartialEq, Eq)]
     88 pub struct RadrootsSimplexAgentMessageReceipt {
     89     pub message_id: RadrootsSimplexAgentMessageId,
     90     pub message_hash: Vec<u8>,
     91     pub receipt_info: Vec<u8>,
     92 }
     93 
     94 #[derive(Debug, Clone, PartialEq, Eq)]
     95 pub enum RadrootsSimplexAgentMessage {
     96     Hello,
     97     UserMessage(Vec<u8>),
     98     Receipt(RadrootsSimplexAgentMessageReceipt),
     99     EncryptionReady {
    100         up_to_message_id: RadrootsSimplexAgentMessageId,
    101     },
    102     QueueContinue(RadrootsSimplexAgentQueueAddress),
    103     QueueAdd(Vec<RadrootsSimplexAgentQueueDescriptor>),
    104     QueueKey(Vec<RadrootsSimplexAgentQueueDescriptor>),
    105     QueueUse(Vec<RadrootsSimplexAgentQueueUseDecision>),
    106     QueueTest(Vec<RadrootsSimplexAgentQueueAddress>),
    107 }
    108 
    109 #[derive(Debug, Clone, PartialEq, Eq)]
    110 pub struct RadrootsSimplexAgentMessageFrame {
    111     pub header: RadrootsSimplexAgentMessageHeader,
    112     pub message: RadrootsSimplexAgentMessage,
    113     pub padding: Vec<u8>,
    114 }
    115 
    116 #[derive(Debug, Clone, PartialEq, Eq)]
    117 pub enum RadrootsSimplexAgentDecryptedMessage {
    118     ConnectionInfo(Vec<u8>),
    119     ConnectionInfoReply {
    120         reply_queues: Vec<RadrootsSimplexAgentQueueDescriptor>,
    121         info: Vec<u8>,
    122     },
    123     RatchetInfo(Vec<u8>),
    124     Message(RadrootsSimplexAgentMessageFrame),
    125 }
    126 
    127 #[derive(Debug, Clone, PartialEq, Eq)]
    128 pub struct RadrootsSimplexAgentEncryptedPayload {
    129     pub ratchet_header: Option<RadrootsSimplexSmpRatchetHeader>,
    130     pub official_message: Option<Vec<u8>>,
    131     pub ciphertext: Vec<u8>,
    132 }
    133 
    134 #[derive(Debug, Clone, PartialEq, Eq)]
    135 pub enum RadrootsSimplexAgentEnvelope {
    136     Confirmation {
    137         reply_queue: bool,
    138         e2e_ratchet_params: Option<RadrootsSimplexOfficialX3dhParams>,
    139         encrypted: RadrootsSimplexAgentEncryptedPayload,
    140     },
    141     Message(RadrootsSimplexAgentEncryptedPayload),
    142     Invitation {
    143         request: Vec<u8>,
    144         connection_info: Vec<u8>,
    145     },
    146     RatchetKey {
    147         info: Vec<u8>,
    148         encrypted: RadrootsSimplexAgentEncryptedPayload,
    149     },
    150 }