refactor(account): keep all accounts in memory

Cargo.toml

@@ -15,7 +15,7 @@ serde_repr = "0.1"
 once_cell = "1.4"
 iota-core = { git = "https://github.com/iotaledger/iota.rs", branch = "dev" }
 url = { version = "2.1", features = [ "serde" ] }
-tokio = "0.2"
+tokio = { version = "0.2", features = ["macros", "sync"] }
 rand = "0.3"
 rusqlite = { version = "0.23", features = ["bundled"], optional = true }
 slip10 = "0.4"

README.md

@@ -80,16 +80,18 @@ use iota_wallet::{
     storage::sqlite::SqliteStorageAdapter,
 };
 use std::path::PathBuf;
+
 #[tokio::main]
 async fn main() -> iota_wallet::Result<()> {
     let storage_folder: PathBuf = "./my-db".into();
     let manager =
-        AccountManager::with_storage_adapter(&storage_folder, SqliteStorageAdapter::new(&storage_folder, "accounts")?)?;
+        AccountManager::with_storage_adapter(&storage_folder, SqliteStorageAdapter::new(&storage_folder, "accounts")?).await?;
     let client_options = ClientOptionsBuilder::node("http://api.lb-0.testnet.chrysalis2.com")?.build();
     let account = manager
         .create_account(client_options)
         .signer_type(SignerType::EnvMnemonic)
-        .initialise()?;
+        .initialise()
+        .await?;
     Ok(())
 }
 ```

bindings/node/README.md

@@ -63,10 +63,6 @@ Creates a new instance of the AccountManager.
 | [storagePath] | <code>string</code> | <code>undefined</code> | The path where the database file will be saved        |
 | [storageType] | <code>number</code> | <code>undefined</code> | The type of the database.  Stronghold = 1, Sqlite = 2 |
 
-#### startBackgroundSync(): void
-
-Initialises the background polling mechanism and MQTT monitoring. Automatically called on `setStrongholdPassword`.
-
 #### setStrongholdPassword(password): void
 
 Sets the stronghold password and initialises it.

bindings/node/lib/index.d.ts

@@ -128,7 +128,6 @@ export declare interface ManagerOptions {
 
 export declare class AccountManager {
   constructor(storagePath?: string)
-  startBackgroundSync(): void
   setStrongholdPassword(password: string): void
   createAccount(account: AccountToCreate): Account
   getAccount(accountId: string | number): Account | undefined

bindings/node/native/src/classes/account/mod.rs

@@ -3,39 +3,26 @@
 
 use std::str::FromStr;
 
-use iota_wallet::{
-    account::{Account, AccountIdentifier},
-    message::MessageId,
-};
+use iota_wallet::{account::AccountIdentifier, message::MessageId};
 use neon::prelude::*;
 
 mod sync;
 
-pub struct AccountWrapper(pub String);
-
-impl Drop for AccountWrapper {
-    fn drop(&mut self) {
-        crate::remove_account(&self.0);
-    }
-}
+pub struct AccountWrapper(pub AccountIdentifier);
 
 declare_types! {
     pub class JsAccount for AccountWrapper {
         init(mut cx) {
-            let account = cx.argument::<JsString>(0)?.value();
-            let account: Account = serde_json::from_str(&account).expect("invalid account JSON");
-            let id = crate::store_account(account);
-            Ok(AccountWrapper(id))
+            let account_id = cx.argument::<JsString>(0)?.value();
+            Ok(AccountWrapper(serde_json::from_str(&account_id).expect("invalid account identifier")))
         }
 
         method id(mut cx) {
             let id = {
                 let this = cx.this();
                 let guard = cx.lock();
                 let id = &this.borrow(&guard).0;
-                let account = crate::get_account(id);
-                let account = account.read().unwrap();
-                account.id().clone()
+                id.clone()
             };
 
             match id {
@@ -49,9 +36,8 @@ declare_types! {
                 let this = cx.this();
                 let guard = cx.lock();
                 let id = &this.borrow(&guard).0;
-                let account = crate::get_account(id);
-                let account = account.read().unwrap();
-                *account.index()
+                let account_handle = crate::get_account(id);
+                crate::block_on(async move { account_handle.index().await })
             };
 
             Ok(cx.number(index as f64).upcast())
@@ -62,9 +48,8 @@ declare_types! {
                 let this = cx.this();
                 let guard = cx.lock();
                 let id = &this.borrow(&guard).0;
-                let account = crate::get_account(id);
-                let account = account.read().unwrap();
-                account.alias().clone()
+                let account_handle = crate::get_account(id);
+                crate::block_on(async move { account_handle.alias().await })
             };
 
             Ok(cx.string(alias).upcast())
@@ -75,9 +60,8 @@ declare_types! {
                 let this = cx.this();
                 let guard = cx.lock();
                 let id = &this.borrow(&guard).0;
-                let account = crate::get_account(id);
-                let account = account.read().unwrap();
-                account.available_balance()
+                let account_handle = crate::get_account(id);
+                crate::block_on(async move { account_handle.available_balance().await })
             };
             Ok(cx.number(balance as f64).upcast())
         }
@@ -87,9 +71,8 @@ declare_types! {
                 let this = cx.this();
                 let guard = cx.lock();
                 let id = &this.borrow(&guard).0;
-                let account = crate::get_account(id);
-                let account = account.read().unwrap();
-                account.total_balance()
+                let account_handle = crate::get_account(id);
+                crate::block_on(async move { account_handle.total_balance().await })
             };
             Ok(cx.number(balance as f64).upcast())
         }
@@ -113,17 +96,19 @@ declare_types! {
 
             let this = cx.this();
             let id = cx.borrow(&this, |r| r.0.clone());
-            let account = crate::get_account(&id);
-            let account = account.read().unwrap();
-            let messages = account.list_messages(count, from, filter);
-
-            let js_array = JsArray::new(&mut cx, messages.len() as u32);
-            for (index, message) in messages.iter().enumerate() {
-                let value = neon_serde::to_value(&mut cx, &message)?;
-                js_array.set(&mut cx, index as u32, value)?;
-            }
+            let account_handle = crate::get_account(&id);
+            crate::block_on(async move {
+                let account = account_handle.read().await;
+                let messages = account.list_messages(count, from, filter);
+
+                let js_array = JsArray::new(&mut cx, messages.len() as u32);
+                for (index, message) in messages.iter().enumerate() {
+                    let value = neon_serde::to_value(&mut cx, &message)?;
+                    js_array.set(&mut cx, index as u32, value)?;
+                }
 
-            Ok(js_array.upcast())
+                Ok(js_array.upcast())
+            })
         }
 
         method listAddresses(mut cx) {
@@ -134,17 +119,19 @@ declare_types! {
 
             let this = cx.this();
             let id = cx.borrow(&this, |r| r.0.clone());
-            let account = crate::get_account(&id);
-            let account = account.read().unwrap();
-            let addresses = account.list_addresses(unspent);
-
-            let js_array = JsArray::new(&mut cx, addresses.len() as u32);
-            for (index, address) in addresses.iter().enumerate() {
-                let value = neon_serde::to_value(&mut cx, &address)?;
-                js_array.set(&mut cx, index as u32, value)?;
-            }
+            let account_handle = crate::get_account(&id);
+            crate::block_on(async move {
+                let account = account_handle.read().await;
+                let addresses = account.list_addresses(unspent);
+
+                let js_array = JsArray::new(&mut cx, addresses.len() as u32);
+                for (index, address) in addresses.iter().enumerate() {
+                    let value = neon_serde::to_value(&mut cx, &address)?;
+                    js_array.set(&mut cx, index as u32, value)?;
+                }
 
-            Ok(js_array.upcast())
+                Ok(js_array.upcast())
+            })
         }
 
         method setAlias(mut cx) {
@@ -153,10 +140,8 @@ declare_types! {
                 let this = cx.this();
                 let guard = cx.lock();
                 let id = &this.borrow(&guard).0;
-                let account = crate::get_account(id);
-                let mut account = account.write().unwrap();
-                account.set_alias(alias);
-                account.save_pending_changes().expect("failed to save account");
+                let account_handle = crate::get_account(id);
+                crate::block_on(async move { account_handle.set_alias(alias).await; });
             }
             Ok(cx.undefined().upcast())
         }
@@ -168,10 +153,8 @@ declare_types! {
                 let this = cx.this();
                 let guard = cx.lock();
                 let id = &this.borrow(&guard).0;
-                let account = crate::get_account(id);
-                let mut account = account.write().unwrap();
-                account.set_client_options(client_options);
-                account.save_pending_changes().expect("failed to save account");
+                let account_handle = crate::get_account(id);
+                crate::block_on(async move { account_handle.set_client_options(client_options).await; });
             }
             Ok(cx.undefined().upcast())
         }
@@ -180,37 +163,42 @@ declare_types! {
             let message_id = MessageId::from_str(cx.argument::<JsString>(0)?.value().as_str()).expect("invalid message id length");
             let this = cx.this();
             let id = cx.borrow(&this, |r| r.0.clone());
-            let account = crate::get_account(&id);
-            let account = account.read().unwrap();
-            let message = account.get_message(&message_id);
-            match message {
-                Some(m) => Ok(neon_serde::to_value(&mut cx, &m)?),
-                None => Ok(cx.undefined().upcast())
-            }
+            crate::block_on(async move {
+                let account_handle = crate::get_account(&id);
+                let account = account_handle.read().await;
+                let message = account.get_message(&message_id);
+                match message {
+                    Some(m) => Ok(neon_serde::to_value(&mut cx, &m)?),
+                    None => Ok(cx.undefined().upcast())
+                }
+            })
         }
 
         method generateAddress(mut cx) {
             let address = {
                 let this = cx.this();
                 let guard = cx.lock();
                 let id = &this.borrow(&guard).0;
-                let account = crate::get_account(id);
-                let mut account = account.write().unwrap();
-                account.generate_address().expect("error generating address")
+                crate::block_on(async move {
+                    let account_handle = crate::get_account(id);
+                    account_handle.generate_address().await.expect("error generating address")
+                })
             };
             Ok(neon_serde::to_value(&mut cx, &address)?)
         }
 
         method latestAddress(mut cx) {
             let this = cx.this();
             let id = cx.borrow(&this, |r| r.0.clone());
-            let account = crate::get_account(&id);
-            let account = account.read().unwrap();
-            let address = account.latest_address();
-            match address {
-                Some(a) => Ok(neon_serde::to_value(&mut cx, &a)?),
-                None => Ok(cx.undefined().upcast())
-            }
+            crate::block_on(async move {
+                let account_handle = crate::get_account(&id);
+                let account = account_handle.read().await;
+                let address = account.latest_address();
+                match address {
+                    Some(a) => Ok(neon_serde::to_value(&mut cx, &a)?),
+                    None => Ok(cx.undefined().upcast())
+                }
+            })
         }
 
         method sync(mut cx) {

bindings/node/native/src/classes/account/sync.rs

@@ -1,7 +1,10 @@
 // Copyright 2020 IOTA Stiftung
 // SPDX-License-Identifier: Apache-2.0
 
-use iota_wallet::{account::SyncedAccount, WalletError};
+use iota_wallet::{
+    account::{AccountIdentifier, SyncedAccount},
+    WalletError,
+};
 use neon::prelude::*;
 use serde::Deserialize;
 
@@ -16,7 +19,7 @@ pub struct SyncOptions {
 }
 
 pub struct SyncTask {
-    pub account_id: String,
+    pub account_id: AccountIdentifier,
     pub options: SyncOptions,
 }
 
@@ -26,30 +29,30 @@ impl Task for SyncTask {
     type JsEvent = JsValue;
 
     fn perform(&self) -> Result<Self::Output, Self::Error> {
-        let account = crate::get_account(&self.account_id);
-        let mut acc = account.write().unwrap();
-        let mut synchronizer = acc.sync();
-        if let Some(address_index) = self.options.address_index {
-            synchronizer = synchronizer.address_index(address_index);
-        }
-        if let Some(gap_limit) = self.options.gap_limit {
-            synchronizer = synchronizer.gap_limit(gap_limit);
-        }
-        if let Some(skip_persistance) = self.options.skip_persistance {
-            if skip_persistance {
-                synchronizer = synchronizer.skip_persistance();
+        crate::block_on(async move {
+            let account = crate::get_account(&self.account_id);
+            let mut synchronizer = account.sync().await;
+            if let Some(address_index) = self.options.address_index {
+                synchronizer = synchronizer.address_index(address_index);
             }
-        }
-        crate::block_on(crate::convert_async_panics(|| async { synchronizer.execute().await }))
+            if let Some(gap_limit) = self.options.gap_limit {
+                synchronizer = synchronizer.gap_limit(gap_limit);
+            }
+            if let Some(skip_persistance) = self.options.skip_persistance {
+                if skip_persistance {
+                    synchronizer = synchronizer.skip_persistance();
+                }
+            }
+            synchronizer.execute().await
+        })
     }
 
     fn complete(self, mut cx: TaskContext, value: Result<Self::Output, Self::Error>) -> JsResult<Self::JsEvent> {
         match value {
             Ok(val) => {
-                let synced = serde_json::to_string(&val).unwrap();
-                let synced = cx.string(synced);
-                let account_id = cx.string(&self.account_id);
-                Ok(crate::JsSyncedAccount::new(&mut cx, vec![synced, account_id])?.upcast())
+                let id = crate::store_synced_account(val);
+                let id = cx.string(id);
+                Ok(crate::JsSyncedAccount::new(&mut cx, vec![id])?.upcast())
             }
             Err(e) => cx.throw_error(e.to_string()),
         }

bindings/node/native/src/classes/account_manager/internal_transfer.rs

@@ -3,13 +3,13 @@
 
 use std::sync::{Arc, RwLock};
 
-use iota_wallet::{account_manager::AccountManager, message::Message, WalletError};
+use iota_wallet::{account::AccountIdentifier, account_manager::AccountManager, message::Message, WalletError};
 use neon::prelude::*;
 
 pub struct InternalTransferTask {
     pub manager: Arc<RwLock<AccountManager>>,
-    pub from_account_id: String,
-    pub to_account_id: String,
+    pub from_account_id: AccountIdentifier,
+    pub to_account_id: AccountIdentifier,
     pub amount: u64,
 }
 
@@ -21,18 +21,9 @@ impl Task for InternalTransferTask {
     fn perform(&self) -> Result<Self::Output, Self::Error> {
         let manager = self.manager.read().unwrap();
         crate::block_on(crate::convert_async_panics(|| async {
-            let from_account = crate::get_account(&self.from_account_id);
-            let from_account = from_account.read().unwrap();
-            let to_account = crate::get_account(&self.to_account_id);
-            let to_account = to_account.read().unwrap();
-            let res = manager
-                .internal_transfer(from_account.id(), to_account.id(), self.amount)
-                .await?;
-
-            crate::update_account(&self.from_account_id, res.from_account);
-            crate::update_account(&self.to_account_id, res.to_account);
-
-            Ok(res.message)
+            manager
+                .internal_transfer(&self.from_account_id, &self.to_account_id, self.amount)
+                .await
         }))
     }