use dashmap::DashMap;
use ed25519_dalek::{Signer, SigningKey, Verifier, VerifyingKey};
use rand::rngs::OsRng;
use std::sync::Arc;
pub type KeyError = String;
pub trait DidKeyringService: Send + Sync {
fn sign(&self, did: &str, payload: &[u8]) -> Result<Vec<u8>, KeyError>;
fn verify(&self, did: &str, payload: &[u8], sig: &[u8]) -> Result<bool, KeyError>;
fn get_public_key(&self, did: &str) -> Result<Vec<u8>, KeyError>;
}
pub struct InMemoryDidKeyring {
keys: Arc<DashMap<String, (SigningKey, [u8; 32])>>,
}
impl InMemoryDidKeyring {
pub fn new() -> Self {
Self {
keys: Arc::new(DashMap::new()),
}
}
pub fn generate_keypair(&self) -> String {
let mut csprng = OsRng;
let signing_key = SigningKey::generate(&mut csprng);
let pub_bytes = signing_key.verifying_key().to_bytes();
let did = crate::identity::derive_did_key(&pub_bytes);
self.keys.insert(did.clone(), (signing_key, pub_bytes));
did
}
pub fn register_key(&self, signing_key: SigningKey) -> String {
let pub_bytes = signing_key.verifying_key().to_bytes();
let did = crate::identity::derive_did_key(&pub_bytes);
self.keys.insert(did.clone(), (signing_key, pub_bytes));
did
}
}
impl Default for InMemoryDidKeyring {
fn default() -> Self {
Self::new()
}
}
impl DidKeyringService for InMemoryDidKeyring {
fn sign(&self, did: &str, payload: &[u8]) -> Result<Vec<u8>, KeyError> {
let entry = self
.keys
.get(did)
.ok_or_else(|| format!("DID '{}' not registered in keyring", did))?;
let (signing_key, _) = entry.value();
let sig = signing_key.sign(payload);
Ok(sig.to_vec())
}
fn verify(&self, did: &str, payload: &[u8], sig: &[u8]) -> Result<bool, KeyError> {
let pub_bytes = self.get_public_key(did)?;
if pub_bytes.len() != 32 {
return Ok(false);
}
let mut arr = [0u8; 32];
arr.copy_from_slice(&pub_bytes);
let verifying_key = VerifyingKey::from_bytes(&arr).map_err(|e| e.to_string())?;
if sig.len() != 64 {
return Ok(false);
}
let mut sig_arr = [0u8; 64];
sig_arr.copy_from_slice(sig);
let signature = ed25519_dalek::Signature::from_bytes(&sig_arr);
Ok(verifying_key.verify(payload, &signature).is_ok())
}
fn get_public_key(&self, did: &str) -> Result<Vec<u8>, KeyError> {
if let Some(entry) = self.keys.get(did) {
return Ok(entry.value().1.to_vec());
}
if did.starts_with(crate::layer0::vocabulary_identities::DID_KEY_Z) {
let b58_part = &did[9..];
let decoded = bs58::decode(b58_part).into_vec().map_err(|e| e.to_string())?;
if decoded.len() >= 34 && decoded[0] == 0xed && decoded[1] == 0x01 {
return Ok(decoded[2..34].to_vec());
}
}
Err(format!("Could not extract public key for DID: {}", did))
}
}