Struct mutiny_core::storage::MemoryStorage

pub struct MemoryStorage {
    pub password: Option<String>,
    pub cipher: Option<Cipher>,
    pub memory: Arc<RwLock<HashMap<String, Value>>>,
    pub vss_client: Option<Arc<MutinyVssClient>>,
}

Fields

password: Option<String>

cipher: Option<Cipher>

memory: Arc<RwLock<HashMap<String, Value>>>

vss_client: Option<Arc<MutinyVssClient>>

Implementations

impl MemoryStorage

pub fn new( password: Option<String>, cipher: Option<Cipher>, vss_client: Option<Arc<MutinyVssClient>> ) -> Self

pub async fn load_from_vss(&self) -> Result<(), MutinyError>

Trait Implementations

impl Clone for MemoryStorage

fn clone(&self) -> MemoryStorage

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for MemoryStorage

fn default() -> Self

Returns the “default value” for a type.

impl MutinyStorage for MemoryStorage

fn password(&self) -> Option<&str>

Get the password used to encrypt the storage

fn cipher(&self) -> Option<Cipher>

Get the encryption key used for storage

fn vss_client(&self) -> Option<Arc<MutinyVssClient>>

Get the VSS client used for storage

fn set<T>(&self, key: impl AsRef<str>, value: T) -> Result<(), MutinyError>where T: Serialize,

Set a value in the storage, the value will already be encrypted if needed

fn get<T>(&self, key: impl AsRef<str>) -> Result<Option<T>, MutinyError>where T: for<'de> Deserialize<'de>,

Get a value from the storage, use get_data if you want the value to be decrypted

fn delete(&self, keys: &[impl AsRef<str>]) -> Result<(), MutinyError>

Delete a set of values from the storage

async fn start(&mut self) -> Result<(), MutinyError>

Start the storage, this will be called before any other methods

fn stop(&self)

Stop the storage, this will be called when the application is shutting down

fn connected(&self) -> Result<bool, MutinyError>

Check if the storage is connected

fn scan_keys( &self, prefix: &str, suffix: Option<&str> ) -> Result<Vec<String>, MutinyError>

Scan the storage for keys with a given prefix and suffix, this will return a list of keys If this function does not properly filter the keys, it can cause major problems.

fn change_password( &mut self, new: Option<String>, new_cipher: Option<Cipher> ) -> Result<(), MutinyError>

async fn import(_json: Value) -> Result<(), MutinyError>

Override the storage with the new JSON object

async fn clear() -> Result<(), MutinyError>

Deletes all data from the storage

async fn fetch_device_lock(&self) -> Result<Option<DeviceLock>, MutinyError>

async fn set_async<T>( &self, key: impl AsRef<str>, value: T ) -> Result<(), MutinyError>where T: Serialize,

Set a value in the storage, the value will already be encrypted if needed This is an async version of set, it is not required to implement this If this is not implemented, the default implementation will just call set

fn set_data<T>( &self, key: impl AsRef<str>, value: T, version: Option<u32> ) -> Result<(), MutinyError>where T: Serialize,

Set a value in the storage, the function will encrypt the value if needed

async fn set_data_async<T>( &self, key: impl AsRef<str>, value: T, version: Option<u32> ) -> Result<(), MutinyError>where T: Serialize,

Set a value in the storage, the function will encrypt the value if needed

fn get_data<T>(&self, key: impl AsRef<str>) -> Result<Option<T>, MutinyError>where T: for<'de> Deserialize<'de>,

Get a value from the storage, the function will decrypt the value if needed

fn scan<T>( &self, prefix: &str, suffix: Option<&str> ) -> Result<HashMap<String, T>, MutinyError>where T: for<'de> Deserialize<'de>,

Scan the storage for keys with a given prefix and suffix, and then gets their values

fn insert_mnemonic(&self, mnemonic: Mnemonic) -> Result<Mnemonic, MutinyError>

Insert a mnemonic into the storage

fn get_mnemonic(&self) -> Result<Option<Mnemonic>, MutinyError>

Get the mnemonic from the storage

fn change_password_and_rewrite_storage( &mut self, old: Option<String>, new: Option<String> ) -> Result<(), MutinyError>

async fn delete_all(&self) -> Result<(), MutinyError>

Deletes all data from the storage and removes lock from VSS

fn get_nodes(&self) -> Result<NodeStorage, MutinyError>

Gets the node indexes from storage

fn insert_nodes(&self, nodes: NodeStorage) -> Result<(), MutinyError>

Inserts the node indexes into storage

fn get_fee_estimates(&self) -> Result<Option<HashMap<String, f64>>, MutinyError>

Get the current fee estimates from storage The key is block target, the value is the fee in satoshis per byte

fn insert_fee_estimates( &self, fees: HashMap<String, f64> ) -> Result<(), MutinyError>

Inserts the fee estimates into storage The key is block target, the value is the fee in satoshis per byte

fn get_bitcoin_price_cache(&self) -> Result<HashMap<String, f32>, MutinyError>

Get the current bitcoin price cache from storage

fn insert_bitcoin_price_cache( &self, prices: HashMap<String, f32> ) -> Result<(), MutinyError>

Inserts the bitcoin price cache into storage

fn has_done_first_sync(&self) -> Result<bool, MutinyError>

fn set_done_first_sync(&self) -> Result<(), MutinyError>

fn get_device_id(&self) -> Result<String, MutinyError>

fn get_device_lock(&self) -> Result<Option<DeviceLock>, MutinyError>

async fn set_device_lock(&self) -> Result<(), MutinyError>