radrootsd

JSON-RPC bridge for Radroots event publishing
git clone https://radroots.dev/git/radrootsd.git
Log | Files | Refs | README | LICENSE

nip44.rs (4415B)

      1 use anyhow::Result;
      2 use jsonrpsee::server::RpcModule;
      3 use serde::{Deserialize, Serialize};
      4 
      5 use crate::transport::jsonrpc::nip46::{client, session};
      6 use crate::transport::jsonrpc::{MethodRegistry, RpcContext, RpcError};
      7 use nostr::nips::nip46::{NostrConnectMethod, NostrConnectRequest, ResponseResult};
      8 
      9 #[derive(Debug, Deserialize)]
     10 struct Nip46Nip44EncryptParams {
     11     session_id: String,
     12     public_key: String,
     13     text: String,
     14 }
     15 
     16 #[derive(Debug, Deserialize)]
     17 struct Nip46Nip44DecryptParams {
     18     session_id: String,
     19     public_key: String,
     20     ciphertext: String,
     21 }
     22 
     23 #[derive(Clone, Debug, Serialize)]
     24 struct Nip46Nip44EncryptResponse {
     25     ciphertext: String,
     26 }
     27 
     28 #[derive(Clone, Debug, Serialize)]
     29 struct Nip46Nip44DecryptResponse {
     30     plaintext: String,
     31 }
     32 
     33 pub fn register(m: &mut RpcModule<RpcContext>, registry: &MethodRegistry) -> Result<()> {
     34     registry.track("nip46.nip44_encrypt");
     35     m.register_async_method("nip46.nip44_encrypt", |params, ctx, _| async move {
     36         let Nip46Nip44EncryptParams {
     37             session_id,
     38             public_key,
     39             text,
     40         } = params
     41             .parse()
     42             .map_err(|e| RpcError::InvalidParams(e.to_string()))?;
     43         let session = session::get_session(ctx.as_ref(), &session_id).await?;
     44         session::require_permission(&session, "nip44_encrypt")?;
     45         let public_key = radroots_nostr::prelude::radroots_nostr_parse_pubkey(&public_key)
     46             .map_err(|e| RpcError::InvalidParams(format!("invalid public_key: {e}")))?;
     47         let req = NostrConnectRequest::Nip44Encrypt { public_key, text };
     48         let response = client::request(&session, req, "nip44_encrypt").await?;
     49         let response = response
     50             .to_response(NostrConnectMethod::Nip44Encrypt)
     51             .map_err(|e| RpcError::Other(format!("nip46 nip44_encrypt failed: {e}")))?;
     52         if let Some(error) = response.error {
     53             return Err(RpcError::Other(format!(
     54                 "nip46 nip44_encrypt error: {error}"
     55             )));
     56         }
     57         let ciphertext = match response.result {
     58             Some(ResponseResult::Nip44Encrypt { ciphertext }) => ciphertext,
     59             Some(_) => {
     60                 return Err(RpcError::Other(
     61                     "nip46 nip44_encrypt unexpected response".to_string(),
     62                 ));
     63             }
     64             None => {
     65                 return Err(RpcError::Other(
     66                     "nip46 nip44_encrypt missing response".to_string(),
     67                 ));
     68             }
     69         };
     70         Ok::<Nip46Nip44EncryptResponse, RpcError>(Nip46Nip44EncryptResponse { ciphertext })
     71     })?;
     72 
     73     registry.track("nip46.nip44_decrypt");
     74     m.register_async_method("nip46.nip44_decrypt", |params, ctx, _| async move {
     75         let Nip46Nip44DecryptParams {
     76             session_id,
     77             public_key,
     78             ciphertext,
     79         } = params
     80             .parse()
     81             .map_err(|e| RpcError::InvalidParams(e.to_string()))?;
     82         let session = session::get_session(ctx.as_ref(), &session_id).await?;
     83         session::require_permission(&session, "nip44_decrypt")?;
     84         let public_key = radroots_nostr::prelude::radroots_nostr_parse_pubkey(&public_key)
     85             .map_err(|e| RpcError::InvalidParams(format!("invalid public_key: {e}")))?;
     86         let req = NostrConnectRequest::Nip44Decrypt {
     87             public_key,
     88             ciphertext,
     89         };
     90         let response = client::request(&session, req, "nip44_decrypt").await?;
     91         let response = response
     92             .to_response(NostrConnectMethod::Nip44Decrypt)
     93             .map_err(|e| RpcError::Other(format!("nip46 nip44_decrypt failed: {e}")))?;
     94         if let Some(error) = response.error {
     95             return Err(RpcError::Other(format!(
     96                 "nip46 nip44_decrypt error: {error}"
     97             )));
     98         }
     99         let plaintext = match response.result {
    100             Some(ResponseResult::Nip44Decrypt { plaintext }) => plaintext,
    101             Some(_) => {
    102                 return Err(RpcError::Other(
    103                     "nip46 nip44_decrypt unexpected response".to_string(),
    104                 ));
    105             }
    106             None => {
    107                 return Err(RpcError::Other(
    108                     "nip46 nip44_decrypt missing response".to_string(),
    109                 ));
    110             }
    111         };
    112         Ok::<Nip46Nip44DecryptResponse, RpcError>(Nip46Nip44DecryptResponse { plaintext })
    113     })?;
    114 
    115     Ok(())
    116 }