use std::sync::Arc;
use dig_session::{BackendKey, KeychainBackend, Password, Session, UnlockedMasterSeed, SEED_LEN};
use crate::id::AccountId;
const ACCOUNT_KEY_PREFIX: &str = "account.";
#[derive(Debug, thiserror::Error)]
pub enum AccountStoreError {
#[error("account {0} already exists")]
AlreadyExists(AccountId),
#[error("account {0} not found")]
NotFound(AccountId),
#[error("session error: {0}")]
Session(#[from] dig_session::SessionError),
#[error("keystore backend error: {0}")]
Backend(#[from] dig_keystore::KeystoreError),
}
pub type Result<T> = std::result::Result<T, AccountStoreError>;
pub struct AccountStore {
backend: Arc<dyn KeychainBackend>,
}
impl AccountStore {
pub fn new(backend: Arc<dyn KeychainBackend>) -> Self {
Self { backend }
}
fn blob_key(id: &AccountId) -> BackendKey {
BackendKey::new(format!("{ACCOUNT_KEY_PREFIX}{id}"))
}
pub fn exists(&self, id: &AccountId) -> Result<bool> {
Ok(self.backend.exists(&Self::blob_key(id))?)
}
pub(crate) fn enroll(
&self,
id: &AccountId,
password: Password,
seed: &[u8; SEED_LEN],
) -> Result<UnlockedMasterSeed> {
if self.exists(id)? {
return Err(AccountStoreError::AlreadyExists(id.clone()));
}
Ok(Session::enroll_master_seed(
self.backend.clone(),
Self::blob_key(id),
password,
seed,
)?)
}
pub(crate) fn unlock(&self, id: &AccountId, password: Password) -> Result<UnlockedMasterSeed> {
if !self.exists(id)? {
return Err(AccountStoreError::NotFound(id.clone()));
}
Ok(Session::unlock_master_seed(
self.backend.clone(),
Self::blob_key(id),
password,
)?)
}
pub fn list(&self) -> Result<Vec<AccountId>> {
let mut ids: Vec<AccountId> = self
.backend
.list(ACCOUNT_KEY_PREFIX)?
.into_iter()
.filter_map(|key| {
key.as_str()
.strip_prefix(ACCOUNT_KEY_PREFIX)
.map(AccountId::new)
})
.collect();
ids.sort();
Ok(ids)
}
pub fn delete(&self, id: &AccountId) -> Result<()> {
if !self.exists(id)? {
return Err(AccountStoreError::NotFound(id.clone()));
}
self.backend.delete(&Self::blob_key(id))?;
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use dig_keystore::MemoryBackend;
const SEED_A: [u8; SEED_LEN] = [0xAA; SEED_LEN];
const SEED_B: [u8; SEED_LEN] = [0xBB; SEED_LEN];
const PW: &str = "correct horse battery staple";
fn store() -> AccountStore {
AccountStore::new(Arc::new(MemoryBackend::new()))
}
fn id(s: &str) -> AccountId {
AccountId::new(s)
}
#[test]
fn enroll_then_unlock_recovers_the_same_master_seed() {
let ks = store();
let acct = id("acct-1");
let enrolled = ks.enroll(&acct, Password::new(PW), &SEED_A).unwrap();
let enrolled_seed = *enrolled.master_seed();
drop(enrolled);
let unlocked = ks.unlock(&acct, Password::new(PW)).unwrap();
assert_eq!(*unlocked.master_seed(), enrolled_seed);
assert_eq!(*unlocked.master_seed(), SEED_A);
}
#[test]
fn enroll_refuses_to_clobber_an_existing_account() {
let ks = store();
let acct = id("acct-1");
ks.enroll(&acct, Password::new(PW), &SEED_A).unwrap();
let err = ks.enroll(&acct, Password::new(PW), &SEED_B).unwrap_err();
assert!(matches!(err, AccountStoreError::AlreadyExists(_)));
let unlocked = ks.unlock(&acct, Password::new(PW)).unwrap();
assert_eq!(*unlocked.master_seed(), SEED_A);
}
#[test]
fn unlock_with_a_wrong_password_fails_closed() {
let ks = store();
let acct = id("acct-1");
ks.enroll(&acct, Password::new(PW), &SEED_A).unwrap();
assert!(matches!(
ks.unlock(&acct, Password::new("wrong")),
Err(AccountStoreError::Session(_))
));
}
#[test]
fn unlock_and_delete_of_an_unknown_account_report_not_found() {
let ks = store();
let missing = id("nope");
assert!(matches!(
ks.unlock(&missing, Password::new(PW)),
Err(AccountStoreError::NotFound(_))
));
assert!(matches!(
ks.delete(&missing),
Err(AccountStoreError::NotFound(_))
));
}
#[test]
fn list_enumerates_only_enrolled_accounts_sorted() {
let ks = store();
assert!(ks.list().unwrap().is_empty());
ks.enroll(&id("bravo"), Password::new(PW), &SEED_A).unwrap();
ks.enroll(&id("alpha"), Password::new(PW), &SEED_B).unwrap();
assert_eq!(ks.list().unwrap(), vec![id("alpha"), id("bravo")]);
}
#[test]
fn delete_removes_only_the_named_account() {
let ks = store();
ks.enroll(&id("keep"), Password::new(PW), &SEED_A).unwrap();
ks.enroll(&id("drop"), Password::new(PW), &SEED_B).unwrap();
ks.delete(&id("drop")).unwrap();
assert_eq!(ks.list().unwrap(), vec![id("keep")]);
assert!(!ks.exists(&id("drop")).unwrap());
assert!(ks.exists(&id("keep")).unwrap());
}
}