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