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