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 = "setPin", param_kind = map)]
 251     fn set_pin(&self, account: Option<String>, pin: String) -> Result<Value, ErrorObjectOwned>;
 252
 253     #[method(name = "submitRateLimitChallenge", param_kind = map)]
 254     fn submit_rate_limit_challenge(
 255         &self,
 256         account: Option<String>,
 257         challenge: String,
 258         captcha: String,
 259     ) -> Result<Value, ErrorObjectOwned>;
 260
 261     #[method(name = "startChangeNumber", param_kind = map)]
 262     fn start_change_number(
 263         &self,
 264         account: Option<String>,
 265         number: String,
 266         voice: bool,
 267         captcha: Option<String>,
 268     ) -> Result<Value, ErrorObjectOwned>;
 269
 270     #[method(name = "startLink", param_kind = map)]
 271     fn start_link(&self, account: Option<String>) -> Result<JsonLink, ErrorObjectOwned>;
 272
 273     #[method(name = "trust", param_kind = map)]
 274     fn trust(
 275         &self,
 276         account: Option<String>,
 277         recipient: String,
 278         #[allow(non_snake_case)] trustAllKnownKeys: bool,
 279         #[allow(non_snake_case)] verifiedSafetyNumber: Option<String>,
 280     ) -> Result<Value, ErrorObjectOwned>;
 281
 282     #[method(name = "unblock", param_kind = map)]
 283     fn unblock(
 284         &self,
 285         account: Option<String>,
 286         recipients: Vec<String>,
 287         #[allow(non_snake_case)] groupIds: Vec<String>,
 288     ) -> Result<Value, ErrorObjectOwned>;
 289
 290     #[method(name = "unregister", param_kind = map)]
 291     fn unregister(
 292         &self,
 293         account: Option<String>,
 294         #[allow(non_snake_case)] deleteAccount: bool,
 295     ) -> Result<Value, ErrorObjectOwned>;
 296
 297     #[allow(non_snake_case)]
 298     #[method(name = "updateAccount", param_kind = map)]
 299     fn update_account(
 300         &self,
 301         account: Option<String>,
 302         deviceName: Option<String>,
 303         unrestrictedUnidentifiedSender: Option<bool>,
 304         discoverableByNumber: Option<bool>,
 305         numberSharing: Option<bool>,
 306     ) -> Result<Value, ErrorObjectOwned>;
 307
 308     #[method(name = "updateConfiguration", param_kind = map)]
 309     fn update_configuration(
 310         &self,
 311         account: Option<String>,
 312         #[allow(non_snake_case)] readReceipts: Option<bool>,
 313         #[allow(non_snake_case)] unidentifiedDeliveryIndicators: Option<bool>,
 314         #[allow(non_snake_case)] typingIndicators: Option<bool>,
 315         #[allow(non_snake_case)] linkPreviews: Option<bool>,
 316     ) -> Result<Value, ErrorObjectOwned>;
 317
 318     #[method(name = "updateContact", param_kind = map)]
 319     fn update_contact(
 320         &self,
 321         account: Option<String>,
 322         recipient: String,
 323         name: Option<String>,
 324         expiration: Option<u32>,
 325     ) -> Result<Value, ErrorObjectOwned>;
 326
 327     #[method(name = "updateGroup", param_kind = map)]
 328     fn update_group(
 329         &self,
 330         account: Option<String>,
 331         #[allow(non_snake_case)] groupId: Option<String>,
 332         name: Option<String>,
 333         description: Option<String>,
 334         avatar: Option<String>,
 335         member: Vec<String>,
 336         #[allow(non_snake_case)] removeMember: Vec<String>,
 337         admin: Vec<String>,
 338         #[allow(non_snake_case)] removeAdmin: Vec<String>,
 339         ban: Vec<String>,
 340         unban: Vec<String>,
 341         #[allow(non_snake_case)] resetLink: bool,
 342         #[allow(non_snake_case)] link: Option<String>,
 343         #[allow(non_snake_case)] setPermissionAddMember: Option<String>,
 344         #[allow(non_snake_case)] setPermissionEditDetails: Option<String>,
 345         #[allow(non_snake_case)] setPermissionSendMessages: Option<String>,
 346         expiration: Option<u32>,
 347     ) -> Result<Value, ErrorObjectOwned>;
 348
 349     #[method(name = "updateProfile", param_kind = map)]
 350     fn update_profile(
 351         &self,
 352         account: Option<String>,
 353         #[allow(non_snake_case)] givenName: Option<String>,
 354         #[allow(non_snake_case)] familyName: Option<String>,
 355         about: Option<String>,
 356         #[allow(non_snake_case)] aboutEmoji: Option<String>,
 357         #[allow(non_snake_case)] mobileCoinAddress: Option<String>,
 358         avatar: Option<String>,
 359         #[allow(non_snake_case)] removeAvatar: bool,
 360     ) -> Result<Value, ErrorObjectOwned>;
 361
 362     #[method(name = "uploadStickerPack", param_kind = map)]
 363     fn upload_sticker_pack(
 364         &self,
 365         account: Option<String>,
 366         path: String,
 367     ) -> Result<Value, ErrorObjectOwned>;
 368
 369     #[method(name = "verify", param_kind = map)]
 370     fn verify(
 371         &self,
 372         account: Option<String>,
 373         #[allow(non_snake_case)] verificationCode: String,
 374         pin: Option<String>,
 375     ) -> Result<Value, ErrorObjectOwned>;
 376
 377     #[subscription(
 378         name = "subscribeReceive" => "receive",
 379         unsubscribe = "unsubscribeReceive",
 380         item = Value,
 381         param_kind = map
 382     )]
 383     async fn subscribe_receive(&self, account: Option<String>) -> SubscriptionResult;
 384
 385     #[method(name = "version")]
 386     fn version(&self) -> Result<Value, ErrorObjectOwned>;
 387 }
 388
 389 #[derive(Deserialize)]
 390 #[serde(rename_all = "camelCase")]
 391 pub struct JsonLink {
 392     pub device_link_uri: String,
 393 }
 394
 395 pub async fn connect_tcp(
 396     tcp: impl ToSocketAddrs,
 397 ) -> Result<impl SubscriptionClientT, std::io::Error> {
 398     let (sender, receiver) = super::transports::tcp::connect(tcp).await?;
 399
 400     Ok(ClientBuilder::default().build_with_tokio(sender, receiver))
 401 }
 402
 403 pub async fn connect_unix(
 404     socket_path: impl AsRef<Path>,
 405 ) -> Result<impl SubscriptionClientT, std::io::Error> {
 406     let (sender, receiver) = super::transports::ipc::connect(socket_path).await?;
 407
 408     Ok(ClientBuilder::default().build_with_tokio(sender, receiver))
 409 }
 410
 411 pub async fn connect_http(uri: &str) -> Result<impl SubscriptionClientT, Error> {
 412     HttpClientBuilder::default().build(uri)
 413 }