use std::sync::Arc;
#[cfg(test)]
use dig_session::MASTER_SEED_LEN;
use dig_session::{
BackendKey, KeychainBackend, Password, Session, UnlockedMasterSeed, ENTROPY_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,
entropy: &[u8; ENTROPY_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,
entropy,
)?)
}
pub(crate) fn enroll_from_recovery_phrase(
&self,
id: &AccountId,
password: Password,
phrase: &str,
) -> Result<UnlockedMasterSeed> {
if self.exists(id)? {
return Err(AccountStoreError::AlreadyExists(id.clone()));
}
Ok(Session::enroll_from_recovery_phrase(
self.backend.clone(),
Self::blob_key(id),
password,
phrase,
)?)
}
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 ENTROPY_A: [u8; ENTROPY_LEN] = [0xAA; ENTROPY_LEN];
const ENTROPY_B: [u8; ENTROPY_LEN] = [0xBB; ENTROPY_LEN];
fn expanded(entropy: &[u8; ENTROPY_LEN]) -> [u8; MASTER_SEED_LEN] {
bip39::Mnemonic::from_entropy_in(bip39::Language::English, entropy)
.expect("32 bytes is valid 24-word BIP-39 entropy")
.to_seed("")
}
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), &ENTROPY_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(), expanded(&ENTROPY_A));
assert_ne!(unlocked.master_seed()[..ENTROPY_LEN], ENTROPY_A[..]);
}
#[test]
fn enroll_refuses_to_clobber_an_existing_account() {
let ks = store();
let acct = id("acct-1");
ks.enroll(&acct, Password::new(PW), &ENTROPY_A).unwrap();
let err = ks.enroll(&acct, Password::new(PW), &ENTROPY_B).unwrap_err();
assert!(matches!(err, AccountStoreError::AlreadyExists(_)));
let unlocked = ks.unlock(&acct, Password::new(PW)).unwrap();
assert_eq!(*unlocked.master_seed(), expanded(&ENTROPY_A));
}
#[test]
fn the_write_itself_refuses_an_occupied_key_not_merely_the_pre_check() {
let ks = store();
let acct = id("acct-1");
ks.enroll(&acct, Password::new(PW), &ENTROPY_A).unwrap();
let raced = Session::enroll_master_seed(
ks.backend.clone(),
AccountStore::blob_key(&acct),
Password::new(PW),
&ENTROPY_B,
);
let err = AccountStoreError::from(raced.unwrap_err());
assert!(matches!(err, AccountStoreError::Session(_)), "{err}");
let unlocked = ks.unlock(&acct, Password::new(PW)).unwrap();
assert_eq!(*unlocked.master_seed(), expanded(&ENTROPY_A));
}
#[test]
fn unlock_with_a_wrong_password_fails_closed() {
let ks = store();
let acct = id("acct-1");
ks.enroll(&acct, Password::new(PW), &ENTROPY_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), &ENTROPY_A)
.unwrap();
ks.enroll(&id("alpha"), Password::new(PW), &ENTROPY_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), &ENTROPY_A)
.unwrap();
ks.enroll(&id("drop"), Password::new(PW), &ENTROPY_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());
}
}