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         sticker: Option<String>,
 147         #[allow(non_snake_case)] storyTimestamp: Option<u64>,
 148         #[allow(non_snake_case)] storyAuthor: Option<String>,
 149     ) -> Result<Value, ErrorObjectOwned>;
 150
 151     #[method(name = "sendContacts", param_kind = map)]
 152     fn send_contacts(&self, account: Option<String>) -> Result<Value, ErrorObjectOwned>;
 153
 154     #[method(name = "sendPaymentNotification", param_kind = map)]
 155     fn send_payment_notification(
 156         &self,
 157         account: Option<String>,
 158         recipient: String,
 159         receipt: String,
 160         note: String,
 161     ) -> Result<Value, ErrorObjectOwned>;
 162
 163     #[method(name = "sendReaction", param_kind = map)]
 164     fn send_reaction(
 165         &self,
 166         account: Option<String>,
 167         recipients: Vec<String>,
 168         #[allow(non_snake_case)] groupIds: Vec<String>,
 169         #[allow(non_snake_case)] noteToSelf: bool,
 170         emoji: String,
 171         #[allow(non_snake_case)] targetAuthor: String,
 172         #[allow(non_snake_case)] targetTimestamp: u64,
 173         remove: bool,
 174         story: bool,
 175     ) -> Result<Value, ErrorObjectOwned>;
 176
 177     #[method(name = "sendReceipt", param_kind = map)]
 178     fn send_receipt(
 179         &self,
 180         account: Option<String>,
 181         recipient: String,
 182         #[allow(non_snake_case)] targetTimestamps: Vec<u64>,
 183         r#type: String,
 184     ) -> Result<Value, ErrorObjectOwned>;
 185
 186     #[method(name = "sendSyncRequest", param_kind = map)]
 187     fn send_sync_request(&self, account: Option<String>) -> Result<Value, ErrorObjectOwned>;
 188
 189     #[method(name = "sendTyping", param_kind = map)]
 190     fn send_typing(
 191         &self,
 192         account: Option<String>,
 193         recipients: Vec<String>,
 194         #[allow(non_snake_case)] groupIds: Vec<String>,
 195         stop: bool,
 196     ) -> Result<Value, ErrorObjectOwned>;
 197
 198     #[method(name = "setPin", param_kind = map)]
 199     fn set_pin(&self, account: Option<String>, pin: String) -> Result<Value, ErrorObjectOwned>;
 200
 201     #[method(name = "submitRateLimitChallenge", param_kind = map)]
 202     fn submit_rate_limit_challenge(
 203         &self,
 204         account: Option<String>,
 205         challenge: String,
 206         captcha: String,
 207     ) -> Result<Value, ErrorObjectOwned>;
 208
 209     #[method(name = "startLink", param_kind = map)]
 210     fn start_link(&self, account: Option<String>) -> Result<JsonLink, ErrorObjectOwned>;
 211
 212     #[method(name = "trust", param_kind = map)]
 213     fn trust(
 214         &self,
 215         account: Option<String>,
 216         recipient: String,
 217         #[allow(non_snake_case)] trustAllKnownKeys: bool,
 218         #[allow(non_snake_case)] verifiedSafetyNumber: Option<String>,
 219     ) -> Result<Value, ErrorObjectOwned>;
 220
 221     #[method(name = "unblock", param_kind = map)]
 222     fn unblock(
 223         &self,
 224         account: Option<String>,
 225         recipients: Vec<String>,
 226         #[allow(non_snake_case)] groupIds: Vec<String>,
 227     ) -> Result<Value, ErrorObjectOwned>;
 228
 229     #[method(name = "unregister", param_kind = map)]
 230     fn unregister(
 231         &self,
 232         account: Option<String>,
 233         #[allow(non_snake_case)] deleteAccount: bool,
 234     ) -> Result<Value, ErrorObjectOwned>;
 235
 236     #[method(name = "updateAccount", param_kind = map)]
 237     fn update_account(
 238         &self,
 239         account: Option<String>,
 240         #[allow(non_snake_case)] deviceName: Option<String>,
 241     ) -> Result<Value, ErrorObjectOwned>;
 242
 243     #[method(name = "updateConfiguration", param_kind = map)]
 244     fn update_configuration(
 245         &self,
 246         account: Option<String>,
 247         #[allow(non_snake_case)] readReceiptes: Option<bool>,
 248         #[allow(non_snake_case)] unidentifiedDeliveryIndicators: Option<bool>,
 249         #[allow(non_snake_case)] typingIndicators: Option<bool>,
 250         #[allow(non_snake_case)] linkPreviews: Option<bool>,
 251     ) -> Result<Value, ErrorObjectOwned>;
 252
 253     #[method(name = "updateContact", param_kind = map)]
 254     fn update_contact(
 255         &self,
 256         account: Option<String>,
 257         recipient: String,
 258         name: Option<String>,
 259         expiration: Option<u32>,
 260     ) -> Result<Value, ErrorObjectOwned>;
 261
 262     #[method(name = "updateGroup", param_kind = map)]
 263     fn update_group(
 264         &self,
 265         account: Option<String>,
 266         #[allow(non_snake_case)] groupId: Option<String>,
 267         name: Option<String>,
 268         description: Option<String>,
 269         avatar: Option<String>,
 270         member: Vec<String>,
 271         #[allow(non_snake_case)] removeMember: Vec<String>,
 272         admin: Vec<String>,
 273         #[allow(non_snake_case)] removeAdmin: Vec<String>,
 274         ban: Vec<String>,
 275         unban: Vec<String>,
 276         #[allow(non_snake_case)] resetLink: bool,
 277         #[allow(non_snake_case)] link: Option<String>,
 278         #[allow(non_snake_case)] setPermissionAddMember: Option<String>,
 279         #[allow(non_snake_case)] setPermissionEditDetails: Option<String>,
 280         #[allow(non_snake_case)] setPermissionSendMessages: Option<String>,
 281         expiration: Option<u32>,
 282     ) -> Result<Value, ErrorObjectOwned>;
 283
 284     #[method(name = "updateProfile", param_kind = map)]
 285     fn update_profile(
 286         &self,
 287         account: Option<String>,
 288         #[allow(non_snake_case)] givenName: Option<String>,
 289         #[allow(non_snake_case)] familyName: Option<String>,
 290         about: Option<String>,
 291         #[allow(non_snake_case)] aboutEmoji: Option<String>,
 292         #[allow(non_snake_case)] mobileCoinAddress: Option<String>,
 293         avatar: Option<String>,
 294         #[allow(non_snake_case)] removeAvatar: bool,
 295     ) -> Result<Value, ErrorObjectOwned>;
 296
 297     #[method(name = "uploadStickerPack", param_kind = map)]
 298     fn upload_sticker_pack(
 299         &self,
 300         account: Option<String>,
 301         path: String,
 302     ) -> Result<Value, ErrorObjectOwned>;
 303
 304     #[method(name = "verify", param_kind = map)]
 305     fn verify(
 306         &self,
 307         account: Option<String>,
 308         #[allow(non_snake_case)] verificationCode: String,
 309         pin: Option<String>,
 310     ) -> Result<Value, ErrorObjectOwned>;
 311
 312     #[subscription(
 313         name = "subscribeReceive" => "receive",
 314         unsubscribe = "unsubscribeReceive",
 315         item = Value,
 316         param_kind = map
 317     )]
 318     async fn subscribe_receive(&self, account: Option<String>) -> SubscriptionResult;
 319
 320     #[method(name = "version")]
 321     fn version(&self) -> Result<Value, ErrorObjectOwned>;
 322 }
 323
 324 #[derive(Deserialize)]
 325 #[serde(rename_all = "camelCase")]
 326 pub struct JsonLink {
 327     pub device_link_uri: String,
 328 }
 329
 330 pub async fn connect_tcp(tcp: impl ToSocketAddrs) -> Result<impl SubscriptionClientT, Error> {
 331     let (sender, receiver) = super::transports::tcp::connect(tcp).await?;
 332
 333     Ok(ClientBuilder::default().build_with_tokio(sender, receiver))
 334 }
 335
 336 pub async fn connect_unix(
 337     socket_path: impl AsRef<Path>,
 338 ) -> Result<impl SubscriptionClientT, Error> {
 339     let (sender, receiver) = super::transports::ipc::connect(socket_path).await?;
 340
 341     Ok(ClientBuilder::default().build_with_tokio(sender, receiver))
 342 }
 343
 344 pub async fn connect_http(uri: &str) -> Result<impl SubscriptionClientT, Error> {
 345     HttpClientBuilder::default().build(uri)
 346 }