496426090

Build Type

github

Committed by GitHub

Commit Message

Merge 8daa753a5 into 6a14e14b6

Pull Request Pull Request #235: fix(address): stack overflow on PartialEq impl

Run Details

4687 of 22889 branches covered (20.48%)

Branch coverage included in aggregate %.

0 of 1 new or added line in 1 file covered. (0.0%)

11 existing lines in 2 files now uncovered.

1765 of 3496 relevant lines covered (50.49%)

513.63 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

15.79

/src/actor/mod.rs

// Copyright 2020 IOTA Stiftung
// SPDX-License-Identifier: Apache-2.0

use crate::{
    account::AccountIdentifier,
    account_manager::AccountManager,
    message::{Message as WalletMessage, Transfer},
    Result,
};
use futures::{Future, FutureExt};
use iota::message::prelude::MessageId;

use std::{
    any::Any,
    convert::TryInto,
    num::NonZeroU64,
    panic::{catch_unwind, AssertUnwindSafe},
};

mod message;
pub use message::*;

/// The Wallet message handler.
pub struct WalletMessageHandler {
    account_manager: AccountManager,
}

fn panic_to_response_message(panic: Box<dyn Any>) -> Result<ResponseType> {
    let msg = if let Some(message) = panic.downcast_ref::<String>() {
        format!("Internal error: {}", message)
    } else if let Some(message) = panic.downcast_ref::<&str>() {
        format!("Internal error: {}", message)
    } else {
        "Internal error".to_string()
    };
    let current_backtrace = backtrace::Backtrace::new();
    Ok(ResponseType::Panic(format!("{}\n\n{:?}", msg, current_backtrace)))
}

fn convert_panics<F: FnOnce() -> Result<ResponseType>>(f: F) -> Result<ResponseType> {
    match catch_unwind(AssertUnwindSafe(|| f())) {
        Ok(result) => result,
        Err(panic) => panic_to_response_message(panic),
    }
}

async fn convert_async_panics<F>(f: impl FnOnce() -> F) -> Result<ResponseType>
where
    F: Future<Output = Result<ResponseType>>,
{
    match AssertUnwindSafe(f()).catch_unwind().await {
        Ok(result) => result,
        Err(panic) => panic_to_response_message(panic),
    }
}

impl WalletMessageHandler {
    /// Creates a new instance of the message handler with the default account manager.
    pub async fn new() -> Result<Self> {
        let instance = Self {
            account_manager: AccountManager::builder().finish().await?,
        };
        Ok(instance)
    }

    /// Creates a new instance of the message handler with the specified account manager.
    pub fn with_manager(account_manager: AccountManager) -> Result<Self> {
        let instance = Self { account_manager };
        Ok(instance)
    }

    /// Handles a message.
    pub async fn handle(&mut self, message: Message) {
        let response: Result<ResponseType> = match message.message_type() {
            MessageType::RemoveAccount(account_id) => {
                convert_async_panics(|| async { self.remove_account(account_id).await }).await
            }
            MessageType::CreateAccount(account) => {
                convert_async_panics(|| async { self.create_account(account).await }).await
            }
            MessageType::GetAccount(account_id) => {
                convert_async_panics(|| async { self.get_account(account_id).await }).await
            }
            MessageType::GetAccounts => convert_async_panics(|| async { self.get_accounts().await }).await,
            MessageType::CallAccountMethod { account_id, method } => {
                convert_async_panics(|| async { self.call_account_method(account_id, method).await }).await
            }
            MessageType::SyncAccounts => convert_async_panics(|| async { self.sync_accounts().await }).await,
            MessageType::Reattach { account_id, message_id } => {
                convert_async_panics(|| async { self.reattach(account_id, message_id).await }).await
            }
            #[cfg(any(feature = "stronghold-storage", feature = "sqlite-storage"))]
            MessageType::Backup(destination_path) => {
                convert_async_panics(|| async { self.backup(destination_path).await }).await
            }
            #[cfg(any(feature = "stronghold", feature = "stronghold-storage"))]
            MessageType::RestoreBackup { backup_path, password } => {
                convert_async_panics(|| async { self.restore_backup(backup_path, password).await }).await
            }
            #[cfg(not(any(feature = "stronghold", feature = "stronghold-storage")))]
            MessageType::RestoreBackup { backup_path } => {
                convert_async_panics(|| async { self.restore_backup(backup_path).await }).await
            }
            MessageType::SetStoragePassword(password) => {
                convert_async_panics(|| async { self.set_storage_password(password).await }).await
            }
            #[cfg(any(feature = "stronghold", feature = "stronghold-storage"))]
            MessageType::SetStrongholdPassword(password) => {
                convert_async_panics(|| async { self.set_stronghold_password(password).await }).await
            }
            MessageType::GenerateMnemonic => convert_panics(|| {
                self.account_manager
                    .generate_mnemonic()
                    .map(ResponseType::GeneratedMnemonic)
            }),
            MessageType::VerifyMnemonic(mnemonic) => convert_panics(|| {
                self.account_manager
                    .verify_mnemonic(mnemonic)
                    .map(|_| ResponseType::VerifiedMnemonic)
            }),
            MessageType::StoreMnemonic { signer_type, mnemonic } => {
                convert_async_panics(|| async {
                    self.account_manager
                        .store_mnemonic(signer_type.clone(), mnemonic.clone())
                        .await
                        .map(|_| ResponseType::StoredMnemonic)
                })
                .await
            }
            MessageType::SendTransfer { account_id, transfer } => {
                convert_async_panics(|| async { self.send_transfer(account_id, transfer.clone().finish()).await }).await
            }
            MessageType::InternalTransfer {
                from_account_id,
                to_account_id,
                amount,
            } => {
                convert_async_panics(|| async { self.internal_transfer(from_account_id, to_account_id, *amount).await })
                    .await
            }
        };

        let response = match response {
            Ok(r) => r,
            Err(e) => ResponseType::Error(e),
        };
        let _ = message
            .response_tx
            .send(Response::new(message.id().to_string(), message.message_type, response));
    }

    #[cfg(any(feature = "stronghold-storage", feature = "sqlite-storage"))]
    async fn backup(&self, destination_path: &str) -> Result<ResponseType> {
        self.account_manager.backup(destination_path).await?;
        Ok(ResponseType::BackupSuccessful)
    }

    #[cfg(any(feature = "stronghold-storage", feature = "sqlite-storage"))]
    async fn restore_backup(
        &mut self,
        backup_path: &str,
        #[cfg(any(feature = "stronghold", feature = "stronghold-storage"))] password: &str,
    ) -> Result<ResponseType> {
        #[cfg(any(feature = "stronghold", feature = "stronghold-storage"))]
        self.account_manager.import_accounts(backup_path, password).await?;
        #[cfg(not(any(feature = "stronghold", feature = "stronghold-storage")))]
        self.account_manager.import_accounts(backup_path).await?;
        Ok(ResponseType::BackupRestored)
    }

    async fn reattach(&self, account_id: &AccountIdentifier, message_id: &str) -> Result<ResponseType> {
        let parsed_message_id = MessageId::new(
            message_id.as_bytes()[..]
                .try_into()
                .map_err(|_| crate::Error::InvalidMessageId)?,
        );
        self.account_manager
            .reattach(account_id.clone(), &parsed_message_id)
            .await?;
        Ok(ResponseType::Reattached(message_id.to_string()))
    }

    async fn sync_accounts(&self) -> Result<ResponseType> {
        let synced = self.account_manager.sync_accounts().await?;
        Ok(ResponseType::SyncedAccounts(synced))
    }

    async fn call_account_method(
        &self,
        account_id: &AccountIdentifier,
        method: &AccountMethod,
    ) -> Result<ResponseType> {
        let account_handle = self.account_manager.get_account(account_id.clone()).await?;

        match method {
            AccountMethod::GenerateAddress => {
                let address = account_handle.generate_address().await?;
                Ok(ResponseType::GeneratedAddress(address))
            }
            AccountMethod::ListMessages {
                count,
                from,
                message_type,
            } => {
                let account = account_handle.read().await;
                let messages: Vec<WalletMessage> = account
                    .list_messages(*count, *from, message_type.clone())
                    .into_iter()
                    .cloned()
                    .collect();
                Ok(ResponseType::Messages(messages))
            }
            AccountMethod::ListAddresses => {
                let addresses = account_handle.addresses().await;
                Ok(ResponseType::Addresses(addresses))
            }
            AccountMethod::ListSpentAddresses => {
                let addresses = account_handle.list_spent_addresses().await;
                Ok(ResponseType::Addresses(addresses))
            }
            AccountMethod::ListUnspentAddresses => {
                let addresses = account_handle.list_unspent_addresses().await;
                Ok(ResponseType::Addresses(addresses))
            }
            AccountMethod::GetAvailableBalance => {
                let account = account_handle.read().await;
                Ok(ResponseType::AvailableBalance(account.available_balance()))
            }
            AccountMethod::GetTotalBalance => {
                let account = account_handle.read().await;
                Ok(ResponseType::TotalBalance(account.total_balance()))
            }
            AccountMethod::GetLatestAddress => {
                let account = account_handle.read().await;
                Ok(ResponseType::LatestAddress(account.latest_address().cloned()))
            }
            AccountMethod::SyncAccount {
                address_index,
                gap_limit,
                skip_persistance,
            } => {
                let mut synchronizer = account_handle.sync().await;
                if let Some(address_index) = address_index {
                    synchronizer = synchronizer.address_index(*address_index);
                }
                if let Some(gap_limit) = gap_limit {
                    synchronizer = synchronizer.gap_limit(*gap_limit);
                }
                if let Some(skip_persistance) = skip_persistance {
                    if *skip_persistance {
                        synchronizer = synchronizer.skip_persistance();
                    }
                }
                let synced = synchronizer.execute().await?;
                Ok(ResponseType::SyncedAccount(synced))
            }
        }
    }

    /// The remove account message handler.
    async fn remove_account(&self, account_id: &AccountIdentifier) -> Result<ResponseType> {
        self.account_manager
            .remove_account(account_id.clone())
            .await
            .map(|_| ResponseType::RemovedAccount(account_id.clone()))
    }

    /// The create account message handler.
    async fn create_account(&self, account: &AccountToCreate) -> Result<ResponseType> {
        let mut builder = self.account_manager.create_account(account.client_options.clone())?;

        if let Some(alias) = &account.alias {
            builder = builder.alias(alias);
        }
        if let Some(created_at) = &account.created_at {
            builder = builder.created_at(*created_at);
        }
        if account.skip_persistance {
            builder = builder.skip_persistance();
        }
        if let Some(signer_type) = &account.signer_type {
            builder = builder.signer_type(signer_type.clone());
        }

        match builder.initialise().await {
            Ok(account_handle) => {
                let account = account_handle.read().await;
                Ok(ResponseType::CreatedAccount(account.clone()))
            }
            Err(e) => Err(e),
        }
    }

    async fn get_account(&self, account_id: &AccountIdentifier) -> Result<ResponseType> {
        let account_handle = self.account_manager.get_account(account_id.clone()).await?;
        let account = account_handle.read().await;
        Ok(ResponseType::ReadAccount(account.clone()))
    }

    async fn get_accounts(&self) -> Result<ResponseType> {
        let accounts = self.account_manager.get_accounts().await?;
        let mut accounts_ = Vec::new();
        for account_handle in accounts {
            accounts_.push(account_handle.read().await.clone());
        }
        Ok(ResponseType::ReadAccounts(accounts_))
    }

    async fn set_storage_password(&mut self, password: &str) -> Result<ResponseType> {
        self.account_manager.set_storage_password(password).await?;
        Ok(ResponseType::StoragePasswordSet)
    }

    #[cfg(feature = "stronghold")]
    async fn set_stronghold_password(&mut self, password: &str) -> Result<ResponseType> {
        self.account_manager.set_stronghold_password(password).await?;
        Ok(ResponseType::StrongholdPasswordSet)
    }

    async fn send_transfer(&self, account_id: &AccountIdentifier, transfer: Transfer) -> Result<ResponseType> {
        let account = self.account_manager.get_account(account_id.clone()).await?;
        let synced = account.sync().await.execute().await?;
        let message = synced.transfer(transfer).await?;
        Ok(ResponseType::SentTransfer(message))
    }

    async fn internal_transfer(
        &self,
        from_account_id: &AccountIdentifier,
        to_account_id: &AccountIdentifier,
        amount: NonZeroU64,
    ) -> Result<ResponseType> {
        let message = self
            .account_manager
            .internal_transfer(from_account_id.clone(), to_account_id.clone(), amount)
            .await?;
        Ok(ResponseType::SentTransfer(message))
    }
}

#[cfg(test)]
mod tests {
    use super::{AccountToCreate, Message, MessageType, Response, ResponseType, WalletMessageHandler};
    use crate::client::ClientOptionsBuilder;
    use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender};

    /// The wallet actor builder.
    #[derive(Default)]
    pub struct WalletBuilder {
        rx: Option<UnboundedReceiver<Message>>,
        message_handler: Option<WalletMessageHandler>,
    }

    impl WalletBuilder {
        /// Creates a new wallet actor builder.
        pub fn new() -> Self {
            Self::default()
        }

        /// Sets the receiver for messages.
        pub fn rx(mut self, rx: UnboundedReceiver<Message>) -> Self {
            self.rx.replace(rx);
            self
        }

        /// Sets the wallet message handler
        pub fn message_handler(mut self, message_handler: WalletMessageHandler) -> Self {
            self.message_handler.replace(message_handler);
            self
        }

        /// Builds the Wallet actor.
        pub async fn build(self) -> Wallet {
            Wallet {
                rx: self.rx.expect("rx is required"),
                message_handler: self.message_handler.expect("message handler is required"),
            }
        }
    }

    /// The Account actor.
    pub struct Wallet {
        rx: UnboundedReceiver<Message>,
        message_handler: WalletMessageHandler,
    }

    impl Wallet {
        /// Runs the actor.
        pub async fn run(mut self) {
            println!("running wallet actor");

            while let Some(message) = self.rx.recv().await {
                self.message_handler.handle(message).await;
            }
        }
    }

    fn spawn_actor() -> UnboundedSender<Message> {
        let (tx, rx) = unbounded_channel();
        std::thread::spawn(|| {
            let runtime = tokio::runtime::Runtime::new().unwrap();
            runtime.block_on(async move {
                let actor = WalletBuilder::new()
                    .rx(rx)
                    .message_handler(
                        WalletMessageHandler::with_manager(crate::test_utils::get_account_manager().await).unwrap(),
                    )
                    .build()
                    .await;
                actor.run().await
            });
        });
        tx
    }

    async fn send_message(tx: &UnboundedSender<Message>, message_type: MessageType) -> Response {
        let (message_tx, mut message_rx) = unbounded_channel();
        let message = Message::new("".to_string(), message_type, message_tx);
        tx.send(message).unwrap();
        message_rx.recv().await.unwrap()
    }

    #[tokio::test]
    async fn create_and_remove_account() {
        let tx = spawn_actor();

        let signer_type = crate::test_utils::signer_type();

        // create an account
        let account = AccountToCreate {
            client_options: ClientOptionsBuilder::node("http://node.iota").unwrap().build(),
            alias: None,
            created_at: None,
            skip_persistance: false,
            signer_type: Some(signer_type.clone()),
        };
        #[cfg(any(feature = "stronghold", feature = "stronghold-storage"))]
        send_message(&tx, MessageType::SetStrongholdPassword("password".to_string())).await;
        send_message(
            &tx,
            MessageType::StoreMnemonic {
                signer_type,
                mnemonic: None,
            },
        )
        .await;
        let response = send_message(&tx, MessageType::CreateAccount(account)).await;
        match response.response() {
            ResponseType::CreatedAccount(created_account) => {
                let id = created_account.id().clone();
                std::thread::spawn(move || {
                    std::thread::sleep(std::time::Duration::from_secs(6));
                    // remove the created account
                    let response =
                        crate::block_on(async move { send_message(&tx, MessageType::RemoveAccount(id.into())).await });
                    assert!(matches!(response.response(), ResponseType::RemovedAccount(_)));
                });
            }
            _ => panic!("unexpected response {:?}", response),
        }
    }
}

1	// Copyright 2020 IOTA Stiftung	×
2	// SPDX-License-Identifier: Apache-2.0
3
4	use crate::{
5	account::AccountIdentifier,
6	account_manager::AccountManager,
7	message::{Message as WalletMessage, Transfer},
8	Result,
9	};
10	use futures::{Future, FutureExt};
11	use iota::message::prelude::MessageId;
12
13	use std::{
14	any::Any,
15	convert::TryInto,
16	num::NonZeroU64,
17	panic::{catch_unwind, AssertUnwindSafe},
18	};
19
20	mod message;
21	pub use message::*;
22
23	/// The Wallet message handler.
24	pub struct WalletMessageHandler {
25	account_manager: AccountManager,
26	}
27
28	fn panic_to_response_message(panic: Box<dyn Any>) -> Result<ResponseType> {	×
29	let msg = if let Some(message) = panic.downcast_ref::<String>() {	×
30	format!("Internal error: {}", message)	×
31	} else if let Some(message) = panic.downcast_ref::<&str>() {	×
32	format!("Internal error: {}", message)	×
33	} else {
34	"Internal error".to_string()	×
35	};
36	let current_backtrace = backtrace::Backtrace::new();	×
37	Ok(ResponseType::Panic(format!("{}\n\n{:?}", msg, current_backtrace)))	×
38	}	×
39
40	fn convert_panics<F: FnOnce() -> Result<ResponseType>>(f: F) -> Result<ResponseType> {	×
41	match catch_unwind(AssertUnwindSafe(\|\| f())) {	×
42	Ok(result) => result,	×
43	Err(panic) => panic_to_response_message(panic),	×
44	}
45	}	×
46
47	async fn convert_async_panics<F>(f: impl FnOnce() -> F) -> Result<ResponseType>	12✔
48	where
49	F: Future<Output = Result<ResponseType>>,
50	{	28!
51	match AssertUnwindSafe(f()).catch_unwind().await {	28!
52	Ok(result) => result,	6!
53	Err(panic) => panic_to_response_message(panic),	×
54	}
55	}	12✔
56
57	impl WalletMessageHandler {
58	/// Creates a new instance of the message handler with the default account manager.
59	pub async fn new() -> Result<Self> {	×
60	let instance = Self {
61	account_manager: AccountManager::builder().finish().await?,
62	};
63	Ok(instance)
64	}	×
65
66	/// Creates a new instance of the message handler with the specified account manager.
67	pub fn with_manager(account_manager: AccountManager) -> Result<Self> {	2✔
68	let instance = Self { account_manager };	2✔
69	Ok(instance)	2✔
70	}	2✔
71
72	/// Handles a message.
73	pub async fn handle(&mut self, message: Message) {	34!
74	let response: Result<ResponseType> = match message.message_type() {	12!
75	MessageType::RemoveAccount(account_id) => {	6!
UNCOV 76	convert_async_panics(\|\| async { self.remove_account(account_id).await }).await	×
77	}
78	MessageType::CreateAccount(account) => {	2✔
79	convert_async_panics(\|\| async { self.create_account(account).await }).await	24!
80	}
81	MessageType::GetAccount(account_id) => {	×
82	convert_async_panics(\|\| async { self.get_account(account_id).await }).await	×
83	}
84	MessageType::GetAccounts => convert_async_panics(\|\| async { self.get_accounts().await }).await,	×
85	MessageType::CallAccountMethod { account_id, method } => {	×
86	convert_async_panics(\|\| async { self.call_account_method(account_id, method).await }).await	×
87	}
88	MessageType::SyncAccounts => convert_async_panics(\|\| async { self.sync_accounts().await }).await,	×
89	MessageType::Reattach { account_id, message_id } => {	×
90	convert_async_panics(\|\| async { self.reattach(account_id, message_id).await }).await	×
91	}
92	#[cfg(any(feature = "stronghold-storage", feature = "sqlite-storage"))]
93	MessageType::Backup(destination_path) => {	×
94	convert_async_panics(\|\| async { self.backup(destination_path).await }).await	×
95	}
96	#[cfg(any(feature = "stronghold", feature = "stronghold-storage"))]
97	MessageType::RestoreBackup { backup_path, password } => {	×
98	convert_async_panics(\|\| async { self.restore_backup(backup_path, password).await }).await	×
99	}
100	#[cfg(not(any(feature = "stronghold", feature = "stronghold-storage")))]
101	MessageType::RestoreBackup { backup_path } => {
102	convert_async_panics(\|\| async { self.restore_backup(backup_path).await }).await
103	}
104	MessageType::SetStoragePassword(password) => {	×
105	convert_async_panics(\|\| async { self.set_storage_password(password).await }).await	×
106	}
107	#[cfg(any(feature = "stronghold", feature = "stronghold-storage"))]
108	MessageType::SetStrongholdPassword(password) => {	2✔
109	convert_async_panics(\|\| async { self.set_stronghold_password(password).await }).await	8!
110	}
111	MessageType::GenerateMnemonic => convert_panics(\|\| {	×
112	self.account_manager	×
113	.generate_mnemonic()
114	.map(ResponseType::GeneratedMnemonic)
115	}),	×
116	MessageType::VerifyMnemonic(mnemonic) => convert_panics(\|\| {	×
117	self.account_manager	×
118	.verify_mnemonic(mnemonic)	×
119	.map(\|_\| ResponseType::VerifiedMnemonic)	×
120	}),	×
121	MessageType::StoreMnemonic { signer_type, mnemonic } => {	2✔
122	convert_async_panics(\|\| async {	18!
123	self.account_manager	10!
124	.store_mnemonic(signer_type.clone(), mnemonic.clone())	4!
125	.await
126	.map(\|_\| ResponseType::StoredMnemonic)	2✔
127	})	4✔
128	.await
129	}
130	MessageType::SendTransfer { account_id, transfer } => {	×
131	convert_async_panics(\|\| async { self.send_transfer(account_id, transfer.clone().finish()).await }).await	×
132	}
133	MessageType::InternalTransfer {
134	from_account_id,	×
135	to_account_id,	×
136	amount,	×
137	} => {
138	convert_async_panics(\|\| async { self.internal_transfer(from_account_id, to_account_id, *amount).await })	×
139	.await
140	}
141	};
142
143	let response = match response {	6✔
144	Ok(r) => r,	6!
145	Err(e) => ResponseType::Error(e),	×
146	};
147	let _ = message	12!
148	.response_tx
149	.send(Response::new(message.id().to_string(), message.message_type, response));	12!
150	}	18!
151
152	#[cfg(any(feature = "stronghold-storage", feature = "sqlite-storage"))]
153	async fn backup(&self, destination_path: &str) -> Result<ResponseType> {	×
154	self.account_manager.backup(destination_path).await?;	×
155	Ok(ResponseType::BackupSuccessful)	×
156	}	×
157
158	#[cfg(any(feature = "stronghold-storage", feature = "sqlite-storage"))]
159	async fn restore_backup(	×
160	&mut self,	×
161	backup_path: &str,	×
162	#[cfg(any(feature = "stronghold", feature = "stronghold-storage"))] password: &str,	×
163	) -> Result<ResponseType> {	×
164	#[cfg(any(feature = "stronghold", feature = "stronghold-storage"))]
165	self.account_manager.import_accounts(backup_path, password).await?;	×
166	#[cfg(not(any(feature = "stronghold", feature = "stronghold-storage")))]
167	self.account_manager.import_accounts(backup_path).await?;
168	Ok(ResponseType::BackupRestored)	×
169	}	×
170
171	async fn reattach(&self, account_id: &AccountIdentifier, message_id: &str) -> Result<ResponseType> {	×
172	let parsed_message_id = MessageId::new(	×
173	message_id.as_bytes()[..]	×
174	.try_into()
175	.map_err(\|_\| crate::Error::InvalidMessageId)?,	×
176	);	×
177	self.account_manager	×
178	.reattach(account_id.clone(), &parsed_message_id)	×
179	.await?;	×
180	Ok(ResponseType::Reattached(message_id.to_string()))	×
181	}	×
182
183	async fn sync_accounts(&self) -> Result<ResponseType> {	×
184	let synced = self.account_manager.sync_accounts().await?;	×
185	Ok(ResponseType::SyncedAccounts(synced))	×
186	}	×
187
188	async fn call_account_method(	×
189	&self,	×
190	account_id: &AccountIdentifier,	×
191	method: &AccountMethod,	×
192	) -> Result<ResponseType> {	×
193	let account_handle = self.account_manager.get_account(account_id.clone()).await?;	×
194
195	match method {	×
196	AccountMethod::GenerateAddress => {	×
197	let address = account_handle.generate_address().await?;	×
198	Ok(ResponseType::GeneratedAddress(address))	×
199	}
200	AccountMethod::ListMessages {
201	count,	×
202	from,	×
203	message_type,	×
204	} => {
205	let account = account_handle.read().await;	×
206	let messages: Vec<WalletMessage> = account	×
207	.list_messages(count, from, message_type.clone())	×
208	.into_iter()
209	.cloned()
210	.collect();
211	Ok(ResponseType::Messages(messages))	×
212	}	×
213	AccountMethod::ListAddresses => {
214	let addresses = account_handle.addresses().await;	×
215	Ok(ResponseType::Addresses(addresses))	×
216	}
217	AccountMethod::ListSpentAddresses => {
218	let addresses = account_handle.list_spent_addresses().await;	×
219	Ok(ResponseType::Addresses(addresses))	×
220	}
221	AccountMethod::ListUnspentAddresses => {
222	let addresses = account_handle.list_unspent_addresses().await;	×
223	Ok(ResponseType::Addresses(addresses))	×
224	}
225	AccountMethod::GetAvailableBalance => {
226	let account = account_handle.read().await;	×
227	Ok(ResponseType::AvailableBalance(account.available_balance()))	×
228	}	×
229	AccountMethod::GetTotalBalance => {
230	let account = account_handle.read().await;	×
231	Ok(ResponseType::TotalBalance(account.total_balance()))	×
232	}	×
233	AccountMethod::GetLatestAddress => {
234	let account = account_handle.read().await;	×
235	Ok(ResponseType::LatestAddress(account.latest_address().cloned()))	×
236	}	×
237	AccountMethod::SyncAccount {
238	address_index,	×
239	gap_limit,	×
240	skip_persistance,	×
241	} => {
242	let mut synchronizer = account_handle.sync().await;	×
243	if let Some(address_index) = address_index {	×
244	synchronizer = synchronizer.address_index(*address_index);	×
245	}
246	if let Some(gap_limit) = gap_limit {	×
247	synchronizer = synchronizer.gap_limit(*gap_limit);	×
248	}
249	if let Some(skip_persistance) = skip_persistance {	×
250	if *skip_persistance {	×
251	synchronizer = synchronizer.skip_persistance();	×
252	}
253	}
254	let synced = synchronizer.execute().await?;	×
255	Ok(ResponseType::SyncedAccount(synced))	×
256	}
257	}
258	}	×
259
260	/// The remove account message handler.
UNCOV 261	async fn remove_account(&self, account_id: &AccountIdentifier) -> Result<ResponseType> {	×
UNCOV 262	self.account_manager	×
UNCOV 263	.remove_account(account_id.clone())	×
264	.await
UNCOV 265	.map(\|_\| ResponseType::RemovedAccount(account_id.clone()))	×
UNCOV 266	}	×
267
268	/// The create account message handler.
269	async fn create_account(&self, account: &AccountToCreate) -> Result<ResponseType> {	15!
270	let mut builder = self.account_manager.create_account(account.client_options.clone())?;	2!
271
272	if let Some(alias) = &account.alias {	2!
273	builder = builder.alias(alias);	×
274	}
275	if let Some(created_at) = &account.created_at {	2!
276	builder = builder.created_at(*created_at);	×
277	}
278	if account.skip_persistance {	2!
279	builder = builder.skip_persistance();	×
280	}
281	if let Some(signer_type) = &account.signer_type {	4!
282	builder = builder.signer_type(signer_type.clone());	2!
283	}
284
285	match builder.initialise().await {	11!
286	Ok(account_handle) => {	2!
287	let account = account_handle.read().await;	2!
288	Ok(ResponseType::CreatedAccount(account.clone()))	2!
289	}	2!
290	Err(e) => Err(e),	×
291	}
292	}	4!
293
294	async fn get_account(&self, account_id: &AccountIdentifier) -> Result<ResponseType> {	×
295	let account_handle = self.account_manager.get_account(account_id.clone()).await?;	×
296	let account = account_handle.read().await;	×
297	Ok(ResponseType::ReadAccount(account.clone()))	×
298	}	×
299
300	async fn get_accounts(&self) -> Result<ResponseType> {	×
301	let accounts = self.account_manager.get_accounts().await?;	×
302	let mut accounts_ = Vec::new();	×
303	for account_handle in accounts {	×
304	accounts_.push(account_handle.read().await.clone());	×
305	}	×
306	Ok(ResponseType::ReadAccounts(accounts_))	×
307	}	×
308
309	async fn set_storage_password(&mut self, password: &str) -> Result<ResponseType> {	×
310	self.account_manager.set_storage_password(password).await?;	×
311	Ok(ResponseType::StoragePasswordSet)	×
312	}	×
313
314	#[cfg(feature = "stronghold")]
315	async fn set_stronghold_password(&mut self, password: &str) -> Result<ResponseType> {	7!
316	self.account_manager.set_stronghold_password(password).await?;	3!
317	Ok(ResponseType::StrongholdPasswordSet)	2✔
318	}	4✔
319
320	async fn send_transfer(&self, account_id: &AccountIdentifier, transfer: Transfer) -> Result<ResponseType> {	×
321	let account = self.account_manager.get_account(account_id.clone()).await?;	×
322	let synced = account.sync().await.execute().await?;	×
323	let message = synced.transfer(transfer).await?;	×
324	Ok(ResponseType::SentTransfer(message))	×
325	}	×
326
327	async fn internal_transfer(	×
328	&self,	×
329	from_account_id: &AccountIdentifier,	×
330	to_account_id: &AccountIdentifier,	×
331	amount: NonZeroU64,	×
332	) -> Result<ResponseType> {	×
333	let message = self	×
334	.account_manager
335	.internal_transfer(from_account_id.clone(), to_account_id.clone(), amount)	×
336	.await?;	×
337	Ok(ResponseType::SentTransfer(message))	×
338	}	×
339	}
340
341	#[cfg(test)]
342	mod tests {
343	use super::{AccountToCreate, Message, MessageType, Response, ResponseType, WalletMessageHandler};
344	use crate::client::ClientOptionsBuilder;
345	use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender};
346
347	/// The wallet actor builder.
348	#[derive(Default)]	4✔
349	pub struct WalletBuilder {
350	rx: Option<UnboundedReceiver<Message>>,	2✔
351	message_handler: Option<WalletMessageHandler>,	2!
352	}
353
354	impl WalletBuilder {
355	/// Creates a new wallet actor builder.
356	pub fn new() -> Self {	2✔
357	Self::default()	2✔
358	}	2✔
359
360	/// Sets the receiver for messages.
361	pub fn rx(mut self, rx: UnboundedReceiver<Message>) -> Self {	2✔
362	self.rx.replace(rx);	2!
363	self	2✔
364	}	2✔
365
366	/// Sets the wallet message handler
367	pub fn message_handler(mut self, message_handler: WalletMessageHandler) -> Self {	2✔
368	self.message_handler.replace(message_handler);	2!
369	self	2✔
370	}	2✔
371
372	/// Builds the Wallet actor.
373	pub async fn build(self) -> Wallet {	6!
374	Wallet {	2✔
375	rx: self.rx.expect("rx is required"),	2!
376	message_handler: self.message_handler.expect("message handler is required"),	2!
377	}	×
378	}	4✔
379	}
380
381	/// The Account actor.
382	pub struct Wallet {
383	rx: UnboundedReceiver<Message>,
384	message_handler: WalletMessageHandler,
385	}
386
387	impl Wallet {
388	/// Runs the actor.
389	pub async fn run(mut self) {	21!
390	println!("running wallet actor");	2!
391
392	while let Some(message) = self.rx.recv().await {	9!
393	self.message_handler.handle(message).await;	22!
UNCOV 394	}	×
395	}	2✔
396	}
397
398	fn spawn_actor() -> UnboundedSender<Message> {	2✔
399	let (tx, rx) = unbounded_channel();	2✔
400	std::thread::spawn(\|\| {	4!
401	let runtime = tokio::runtime::Runtime::new().unwrap();	2!
402	runtime.block_on(async move {	47!
403	let actor = WalletBuilder::new()	4!
404	.rx(rx)	2!
405	.message_handler(
406	WalletMessageHandler::with_manager(crate::test_utils::get_account_manager().await).unwrap(),	28!
407	)	2!
408	.build()
409	.await;
410	actor.run().await	19!
UNCOV 411	});	×
412	});	2!
413	tx
414	}	2!
415
416	async fn send_message(tx: &UnboundedSender<Message>, message_type: MessageType) -> Response {	28!
417	let (message_tx, mut message_rx) = unbounded_channel();	6!
418	let message = Message::new("".to_string(), message_type, message_tx);	6!
419	tx.send(message).unwrap();	6!
420	message_rx.recv().await.unwrap()	16!
421	}	12!
422
423	#[tokio::test]	18!
424	async fn create_and_remove_account() {	2✔
425	let tx = spawn_actor();	2!
426
427	let signer_type = crate::test_utils::signer_type();	2!
428
429	// create an account
430	let account = AccountToCreate {	4✔
431	client_options: ClientOptionsBuilder::node("http://node.iota").unwrap().build(),	2!
432	alias: None,	2✔
433	created_at: None,	2✔
434	skip_persistance: false,
435	signer_type: Some(signer_type.clone()),	2!
436	};	×
437	#[cfg(any(feature = "stronghold", feature = "stronghold-storage"))]
438	send_message(&tx, MessageType::SetStrongholdPassword("password".to_string())).await;	8!
439	send_message(	4!
440	&tx,	2✔
441	MessageType::StoreMnemonic {	2✔
442	signer_type,	2✔
443	mnemonic: None,	2!
444	},
445	)
446	.await;	2!
447	let response = send_message(&tx, MessageType::CreateAccount(account)).await;	4!
448	match response.response() {	2!
449	ResponseType::CreatedAccount(created_account) => {	2!
450	let id = created_account.id().clone();	2!
451	std::thread::spawn(move \|\| {	4!
452	std::thread::sleep(std::time::Duration::from_secs(6));	2!
453	// remove the created account
454	let response =
UNCOV 455	crate::block_on(async move { send_message(&tx, MessageType::RemoveAccount(id.into())).await });	×
UNCOV 456	assert!(matches!(response.response(), ResponseType::RemovedAccount(_)));	×
457	});	2!
458	}	×
459	_ => panic!("unexpected response {:?}", response),	×
460	}
461	}	2!
462	}

iotaledger / wallet.rs / 496426090

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous