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 (2604B)

      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             && !ctx
     30                 .state
     31                 .nip46_sessions
     32                 .set_user_pubkey(&session_id, pubkey)
     33                 .await
     34         {
     35             return Err(RpcError::Other("nip46 session update failed".to_string()));
     36         }
     37         Ok::<Nip46GetPublicKeyResponse, RpcError>(Nip46GetPublicKeyResponse {
     38             pubkey: pubkey.to_hex(),
     39         })
     40     })?;
     41     Ok(())
     42 }
     43 
     44 async fn request_get_public_key(
     45     session: &Nip46Session,
     46 ) -> Result<(crate::host_nostr::PublicKey, bool), RpcError> {
     47     let req = NostrConnectRequest::GetPublicKey;
     48     let response = client::request(session, req, "get_public_key").await?;
     49     let response = response
     50         .to_response(NostrConnectMethod::GetPublicKey)
     51         .map_err(|e| RpcError::Other(format!("nip46 get_public_key failed: {e}")))?;
     52 
     53     if let Some(error) = response.error {
     54         return Err(RpcError::Other(format!(
     55             "nip46 get_public_key error: {error}"
     56         )));
     57     }
     58 
     59     let pubkey = match response.result {
     60         Some(ResponseResult::GetPublicKey(pubkey)) => pubkey,
     61         Some(_) => {
     62             return Err(RpcError::Other(
     63                 "nip46 get_public_key unexpected response".to_string(),
     64             ));
     65         }
     66         None => {
     67             return Err(RpcError::Other(
     68                 "nip46 get_public_key missing response".to_string(),
     69             ));
     70         }
     71     };
     72 
     73     let updated = session
     74         .user_pubkey
     75         .map(|existing| existing != pubkey)
     76         .unwrap_or(true);
     77     Ok((pubkey, updated))
     78 }