nmode's Git Repositories - signal-cli/blob - client/src/jsonrpc.rs

   1 use std::path::Path;
   2
   3 use jsonrpsee::async_client::ClientBuilder;
   4 use jsonrpsee::core::client::SubscriptionClientT;
   5 use jsonrpsee::core::Error;
   6 use jsonrpsee::http_client::HttpClientBuilder;
   7 use jsonrpsee::proc_macros::rpc;
   8 use serde::Deserialize;
   9 use serde_json::Value;
  10 use tokio::net::ToSocketAddrs;
  11
  12 #[rpc(client)]
  13 pub trait Rpc {
  14     #[method(name = "addDevice", param_kind = map)]
  15     async fn add_device(
  16         &self,
  17         account: Option<String>,
  18         uri: String,
  19     ) -> Result<Value, ErrorObjectOwned>;
  20
  21     #[method(name = "block", param_kind = map)]
  22     fn block(
  23         &self,
  24         account: Option<String>,
  25         recipients: Vec<String>,
  26         #[allow(non_snake_case)] groupIds: Vec<String>,
  27     ) -> Result<Value, ErrorObjectOwned>;
  28
  29     #[method(name = "deleteLocalAccountData", param_kind = map)]
  30     fn delete_local_account_data(
  31         &self,
  32         account: Option<String>,
  33         #[allow(non_snake_case)] ignoreRegistered: Option<bool>,
  34     ) -> Result<Value, ErrorObjectOwned>;
  35
  36     #[method(name = "getUserStatus", param_kind = map)]
  37     fn get_user_status(
  38         &self,
  39         account: Option<String>,
  40         recipients: Vec<String>,
  41     ) -> Result<Value, ErrorObjectOwned>;
  42
  43     #[method(name = "joinGroup", param_kind = map)]
  44     fn join_group(&self, account: Option<String>, uri: String) -> Result<Value, ErrorObjectOwned>;
  45
  46     #[method(name = "finishLink", param_kind = map)]
  47     fn finish_link(
  48         &self,
  49         #[allow(non_snake_case)] deviceLinkUri: String,
  50         #[allow(non_snake_case)] deviceName: String,
  51     ) -> Result<Value, ErrorObjectOwned>;
  52
  53     #[method(name = "listAccounts", param_kind = map)]
  54     fn list_accounts(&self) -> Result<Value, ErrorObjectOwned>;
  55
  56     #[method(name = "listContacts", param_kind = map)]
  57     fn list_contacts(
  58         &self,
  59         account: Option<String>,
  60         recipients: Vec<String>,
  61         #[allow(non_snake_case)] allRecipients: bool,
  62         blocked: Option<bool>,
  63         name: Option<String>,
  64     ) -> Result<Value, ErrorObjectOwned>;
  65
  66     #[method(name = "listDevices", param_kind = map)]
  67     fn list_devices(&self, account: Option<String>) -> Result<Value, ErrorObjectOwned>;
  68
  69     #[method(name = "listGroups", param_kind = map)]
  70     fn list_groups(
  71         &self,
  72         account: Option<String>,
  73         #[allow(non_snake_case)] groupIds: Vec<String>,
  74     ) -> Result<Value, ErrorObjectOwned>;
  75
  76     #[method(name = "listIdentities", param_kind = map)]
  77     fn list_identities(
  78         &self,
  79         account: Option<String>,
  80         number: Option<String>,
  81     ) -> Result<Value, ErrorObjectOwned>;
  82
  83     #[method(name = "listStickerPacks", param_kind = map)]
  84     fn list_sticker_packs(&self, account: Option<String>) -> Result<Value, ErrorObjectOwned>;
  85
  86     #[method(name = "quitGroup", param_kind = map)]
  87     fn quit_group(
  88         &self,
  89         account: Option<String>,
  90         #[allow(non_snake_case)] groupId: String,
  91         delete: bool,
  92         admins: Vec<String>,
  93     ) -> Result<Value, ErrorObjectOwned>;
  94
  95     #[method(name = "register", param_kind = map)]
  96     fn register(
  97         &self,
  98         account: Option<String>,
  99         voice: bool,
 100         captcha: Option<String>,
 101     ) -> Result<Value, ErrorObjectOwned>;
 102
 103     #[method(name = "removeContact", param_kind = map)]
 104     fn remove_contact(
 105         &self,
 106         account: Option<String>,
 107         recipient: String,
 108         forget: bool,
 109     ) -> Result<Value, ErrorObjectOwned>;
 110
 111     #[method(name = "removeDevice", param_kind = map)]
 112     fn remove_device(
 113         &self,
 114         account: Option<String>,
 115         #[allow(non_snake_case)] deviceId: u32,
 116     ) -> Result<Value, ErrorObjectOwned>;
 117
 118     #[method(name = "removePin", param_kind = map)]
 119     fn remove_pin(&self, account: Option<String>) -> Result<Value, ErrorObjectOwned>;
 120
 121     #[method(name = "remoteDelete", param_kind = map)]
 122     fn remote_delete(
 123         &self,
 124         account: Option<String>,
 125         #[allow(non_snake_case)] targetTimestamp: u64,
 126         recipients: Vec<String>,
 127         #[allow(non_snake_case)] groupIds: Vec<String>,
 128         #[allow(non_snake_case)] noteToSelf: bool,
 129     ) -> Result<Value, ErrorObjectOwned>;
 130
 131     #[method(name = "send", param_kind = map)]
 132     fn send(
 133         &self,
 134         account: Option<String>,
 135         recipients: Vec<String>,
 136         #[allow(non_snake_case)] groupIds: Vec<String>,
 137         #[allow(non_snake_case)] noteToSelf: bool,
 138         #[allow(non_snake_case)] endSession: bool,
 139         message: String,
 140         attachments: Vec<String>,
 141         mentions: Vec<String>,
 142         #[allow(non_snake_case)] quoteTimestamp: Option<u64>,
 143         #[allow(non_snake_case)] quoteAuthor: Option<String>,
 144         #[allow(non_snake_case)] quoteMessage: Option<String>,
 145         #[allow(non_snake_case)] quoteMention: Vec<String>,
 146         #[allow(non_snake_case)] quoteAttachment: Vec<String>,
 147         sticker: Option<String>,
 148         #[allow(non_snake_case)] storyTimestamp: Option<u64>,
 149         #[allow(non_snake_case)] storyAuthor: Option<String>,
 150     ) -> Result<Value, ErrorObjectOwned>;
 151
 152     #[method(name = "sendContacts", param_kind = map)]
 153     fn send_contacts(&self, account: Option<String>) -> Result<Value, ErrorObjectOwned>;
 154
 155     #[method(name = "sendPaymentNotification", param_kind = map)]
 156     fn send_payment_notification(
 157         &self,
 158         account: Option<String>,
 159         recipient: String,
 160         receipt: String,
 161         note: String,
 162     ) -> Result<Value, ErrorObjectOwned>;
 163
 164     #[method(name = "sendReaction", param_kind = map)]
 165     fn send_reaction(
 166         &self,
 167         account: Option<String>,
 168         recipients: Vec<String>,
 169         #[allow(non_snake_case)] groupIds: Vec<String>,
 170         #[allow(non_snake_case)] noteToSelf: bool,
 171         emoji: String,
 172         #[allow(non_snake_case)] targetAuthor: String,
 173         #[allow(non_snake_case)] targetTimestamp: u64,
 174         remove: bool,
 175         story: bool,
 176     ) -> Result<Value, ErrorObjectOwned>;
 177
 178     #[method(name = "sendReceipt", param_kind = map)]
 179     fn send_receipt(
 180         &self,
 181         account: Option<String>,
 182         recipient: String,
 183         #[allow(non_snake_case)] targetTimestamps: Vec<u64>,
 184         r#type: String,
 185     ) -> Result<Value, ErrorObjectOwned>;
 186
 187     #[method(name = "sendSyncRequest", param_kind = map)]
 188     fn send_sync_request(&self, account: Option<String>) -> Result<Value, ErrorObjectOwned>;
 189
 190     #[method(name = "sendTyping", param_kind = map)]
 191     fn send_typing(
 192         &self,
 193         account: Option<String>,
 194         recipients: Vec<String>,
 195         #[allow(non_snake_case)] groupIds: Vec<String>,
 196         stop: bool,
 197     ) -> Result<Value, ErrorObjectOwned>;
 198
 199     #[method(name = "setPin", param_kind = map)]
 200     fn set_pin(&self, account: Option<String>, pin: String) -> Result<Value, ErrorObjectOwned>;
 201
 202     #[method(name = "submitRateLimitChallenge", param_kind = map)]
 203     fn submit_rate_limit_challenge(
 204         &self,
 205         account: Option<String>,
 206         challenge: String,
 207         captcha: String,
 208     ) -> Result<Value, ErrorObjectOwned>;
 209
 210     #[method(name = "startLink", param_kind = map)]
 211     fn start_link(&self, account: Option<String>) -> Result<JsonLink, ErrorObjectOwned>;
 212
 213     #[method(name = "trust", param_kind = map)]
 214     fn trust(
 215         &self,
 216         account: Option<String>,
 217         recipient: String,
 218         #[allow(non_snake_case)] trustAllKnownKeys: bool,
 219         #[allow(non_snake_case)] verifiedSafetyNumber: Option<String>,
 220     ) -> Result<Value, ErrorObjectOwned>;
 221
 222     #[method(name = "unblock", param_kind = map)]
 223     fn unblock(
 224         &self,
 225         account: Option<String>,
 226         recipients: Vec<String>,
 227         #[allow(non_snake_case)] groupIds: Vec<String>,
 228     ) -> Result<Value, ErrorObjectOwned>;
 229
 230     #[method(name = "unregister", param_kind = map)]
 231     fn unregister(
 232         &self,
 233         account: Option<String>,
 234         #[allow(non_snake_case)] deleteAccount: bool,
 235     ) -> Result<Value, ErrorObjectOwned>;
 236
 237     #[method(name = "updateAccount", param_kind = map)]
 238     fn update_account(
 239         &self,
 240         account: Option<String>,
 241         #[allow(non_snake_case)] deviceName: Option<String>,
 242     ) -> Result<Value, ErrorObjectOwned>;
 243
 244     #[method(name = "updateConfiguration", param_kind = map)]
 245     fn update_configuration(
 246         &self,
 247         account: Option<String>,
 248         #[allow(non_snake_case)] readReceiptes: Option<bool>,
 249         #[allow(non_snake_case)] unidentifiedDeliveryIndicators: Option<bool>,
 250         #[allow(non_snake_case)] typingIndicators: Option<bool>,
 251         #[allow(non_snake_case)] linkPreviews: Option<bool>,
 252     ) -> Result<Value, ErrorObjectOwned>;
 253
 254     #[method(name = "updateContact", param_kind = map)]
 255     fn update_contact(
 256         &self,
 257         account: Option<String>,
 258         recipient: String,
 259         name: Option<String>,
 260         expiration: Option<u32>,
 261     ) -> Result<Value, ErrorObjectOwned>;
 262
 263     #[method(name = "updateGroup", param_kind = map)]
 264     fn update_group(
 265         &self,
 266         account: Option<String>,
 267         #[allow(non_snake_case)] groupId: Option<String>,
 268         name: Option<String>,
 269         description: Option<String>,
 270         avatar: Option<String>,
 271         member: Vec<String>,
 272         #[allow(non_snake_case)] removeMember: Vec<String>,
 273         admin: Vec<String>,
 274         #[allow(non_snake_case)] removeAdmin: Vec<String>,
 275         ban: Vec<String>,
 276         unban: Vec<String>,
 277         #[allow(non_snake_case)] resetLink: bool,
 278         #[allow(non_snake_case)] link: Option<String>,
 279         #[allow(non_snake_case)] setPermissionAddMember: Option<String>,
 280         #[allow(non_snake_case)] setPermissionEditDetails: Option<String>,
 281         #[allow(non_snake_case)] setPermissionSendMessages: Option<String>,
 282         expiration: Option<u32>,
 283     ) -> Result<Value, ErrorObjectOwned>;
 284
 285     #[method(name = "updateProfile", param_kind = map)]
 286     fn update_profile(
 287         &self,
 288         account: Option<String>,
 289         #[allow(non_snake_case)] givenName: Option<String>,
 290         #[allow(non_snake_case)] familyName: Option<String>,
 291         about: Option<String>,
 292         #[allow(non_snake_case)] aboutEmoji: Option<String>,
 293         #[allow(non_snake_case)] mobileCoinAddress: Option<String>,
 294         avatar: Option<String>,
 295         #[allow(non_snake_case)] removeAvatar: bool,
 296     ) -> Result<Value, ErrorObjectOwned>;
 297
 298     #[method(name = "uploadStickerPack", param_kind = map)]
 299     fn upload_sticker_pack(
 300         &self,
 301         account: Option<String>,
 302         path: String,
 303     ) -> Result<Value, ErrorObjectOwned>;
 304
 305     #[method(name = "verify", param_kind = map)]
 306     fn verify(
 307         &self,
 308         account: Option<String>,
 309         #[allow(non_snake_case)] verificationCode: String,
 310         pin: Option<String>,
 311     ) -> Result<Value, ErrorObjectOwned>;
 312
 313     #[subscription(
 314         name = "subscribeReceive" => "receive",
 315         unsubscribe = "unsubscribeReceive",
 316         item = Value,
 317         param_kind = map
 318     )]
 319     async fn subscribe_receive(&self, account: Option<String>) -> SubscriptionResult;
 320
 321     #[method(name = "version")]
 322     fn version(&self) -> Result<Value, ErrorObjectOwned>;
 323 }
 324
 325 #[derive(Deserialize)]
 326 #[serde(rename_all = "camelCase")]
 327 pub struct JsonLink {
 328     pub device_link_uri: String,
 329 }
 330
 331 pub async fn connect_tcp(tcp: impl ToSocketAddrs) -> Result<impl SubscriptionClientT, Error> {
 332     let (sender, receiver) = super::transports::tcp::connect(tcp).await?;
 333
 334     Ok(ClientBuilder::default().build_with_tokio(sender, receiver))
 335 }
 336
 337 pub async fn connect_unix(
 338     socket_path: impl AsRef<Path>,
 339 ) -> Result<impl SubscriptionClientT, Error> {
 340     let (sender, receiver) = super::transports::ipc::connect(socket_path).await?;
 341
 342     Ok(ClientBuilder::default().build_with_tokio(sender, receiver))
 343 }
 344
 345 pub async fn connect_http(uri: &str) -> Result<impl SubscriptionClientT, Error> {
 346     HttpClientBuilder::default().build(uri)
 347 }