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

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

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 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>

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