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