radrootsd

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

get_public_key.rs (2655B)

      1 use anyhow::Result;
      2 use jsonrpsee::server::RpcModule;
      3 use serde::{Deserialize, Serialize};
      4 
      5 use crate::core::nip46::Nip46Session;
      6 use crate::transport::jsonrpc::nip46::{client, session};
      7 use crate::transport::jsonrpc::{MethodRegistry, RpcContext, RpcError};
      8 use nostr::nips::nip46::{NostrConnectMethod, NostrConnectRequest, ResponseResult};
      9 
     10 #[derive(Debug, Deserialize)]
     11 struct Nip46GetPublicKeyParams {
     12     session_id: String,
     13 }
     14 
     15 #[derive(Clone, Debug, Serialize)]
     16 struct Nip46GetPublicKeyResponse {
     17     pubkey: String,
     18 }
     19 
     20 pub fn register(m: &mut RpcModule<RpcContext>, registry: &MethodRegistry) -> Result<()> {
     21     registry.track("nip46.get_public_key");
     22     m.register_async_method("nip46.get_public_key", |params, ctx, _| async move {
     23         let Nip46GetPublicKeyParams { session_id } = params
     24             .parse()
     25             .map_err(|e| RpcError::InvalidParams(e.to_string()))?;
     26         let session = session::get_session(ctx.as_ref(), &session_id).await?;
     27         let (pubkey, updated) = request_get_public_key(&session).await?;
     28         if updated {
     29             if !ctx
     30                 .state
     31                 .nip46_sessions
     32                 .set_user_pubkey(&session_id, pubkey.clone())
     33                 .await
     34             {
     35                 return Err(RpcError::Other("nip46 session update failed".to_string()));
     36             }
     37         }
     38         Ok::<Nip46GetPublicKeyResponse, RpcError>(Nip46GetPublicKeyResponse {
     39             pubkey: pubkey.to_hex(),
     40         })
     41     })?;
     42     Ok(())
     43 }
     44 
     45 async fn request_get_public_key(
     46     session: &Nip46Session,
     47 ) -> Result<(radroots_nostr::prelude::RadrootsNostrPublicKey, bool), RpcError> {
     48     let req = NostrConnectRequest::GetPublicKey;
     49     let response = client::request(session, req, "get_public_key").await?;
     50     let response = response
     51         .to_response(NostrConnectMethod::GetPublicKey)
     52         .map_err(|e| RpcError::Other(format!("nip46 get_public_key failed: {e}")))?;
     53 
     54     if let Some(error) = response.error {
     55         return Err(RpcError::Other(format!(
     56             "nip46 get_public_key error: {error}"
     57         )));
     58     }
     59 
     60     let pubkey = match response.result {
     61         Some(ResponseResult::GetPublicKey(pubkey)) => pubkey,
     62         Some(_) => {
     63             return Err(RpcError::Other(
     64                 "nip46 get_public_key unexpected response".to_string(),
     65             ));
     66         }
     67         None => {
     68             return Err(RpcError::Other(
     69                 "nip46 get_public_key missing response".to_string(),
     70             ));
     71         }
     72     };
     73 
     74     let updated = session
     75         .user_pubkey
     76         .map(|existing| existing != pubkey)
     77         .unwrap_or(true);
     78     Ok((pubkey, updated))
     79 }