Merge branch 'move'

Author: benma

src/rust/bitbox02-rust-c/src/workflow.rs

@@ -24,9 +24,9 @@ extern crate alloc;
 
 use alloc::boxed::Box;
 use alloc::string::String;
-use bitbox02_rust::bb02_async::{Task, spin};
 use bitbox02_rust::workflow::confirm;
 use core::task::Poll;
+use util::bb02_async::{Task, spin};
 
 enum TaskState<'a, O> {
     Nothing,

src/rust/bitbox02-rust/Cargo.toml

@@ -101,7 +101,8 @@ app-cardano = [
 ]
 
 testing = [
-  "bitbox02/testing"
+  "bitbox02/testing",
+  "util/testing"
 ]
 
 c-unit-testing = []

src/rust/bitbox02-rust/src/async_usb.rs

@@ -15,11 +15,11 @@
 //! This module provides the executor for tasks that are spawned with an API request and deliver a
 //! USB response. Terminology: host = computer, device = BitBox02.
 
-use crate::bb02_async::{Task, option, spin as spin_task};
 use alloc::boxed::Box;
 use alloc::vec::Vec;
 use core::cell::RefCell;
 use core::task::Poll;
+use util::bb02_async::{Task, option, spin as spin_task};
 
 type UsbOut = Vec<u8>;
 type UsbIn = Vec<u8>;

src/rust/bitbox02-rust/src/bb02_async.rs

@@ -12,59 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use alloc::boxed::Box;
 use core::cell::RefCell;
-use core::pin::Pin;
-use core::task::{Context, Poll};
-
-/// Task is the top-level future which can be polled by an executor.
-/// Note that other futures awaited inside do not have to be pinned.
-/// The 'a lifetime allows to spin a boxed/pinned future that is not
-/// 'static, or a future with non-'static input param references.
-pub type Task<'a, O> = Pin<Box<dyn core::future::Future<Output = O> + 'a>>;
-
-/// A primitive poll invocation for a task, with no waking functionality.
-pub fn spin<O>(task: &mut Task<O>) -> Poll<O> {
-    // TODO: statically allocate the context.
-    let waker = crate::waker_fn::waker_fn(|| {});
-    let context = &mut Context::from_waker(&waker);
-    task.as_mut().poll(context)
-}
-
-/// Implements the Option future, see `option()`.
-pub struct AsyncOption<'a, O>(&'a RefCell<Option<O>>);
-
-impl<O> core::future::Future for AsyncOption<'_, O> {
-    type Output = O;
-    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
-        match self.0.borrow_mut().take() {
-            None => Poll::Pending,
-            Some(output) => Poll::Ready(output),
-        }
-    }
-}
 
 /// Disables the screensaver while waiting for an option to contain a value. Afterwards, it returns that value
 pub async fn option_no_screensaver<O>(opt: &RefCell<Option<O>>) -> O {
     bitbox02::screen_saver::screen_saver_disable();
-    let result = option(opt).await;
+    let result = util::bb02_async::option(opt).await;
     bitbox02::screen_saver::screen_saver_enable();
     result
 }
-
-/// Waits for an option to contain a value and returns that value, leaving `None` in its place.
-/// E.g. `assert_eq!(option(&Some(42)).await, 42)`.
-pub fn option<O>(option: &RefCell<Option<O>>) -> AsyncOption<'_, O> {
-    AsyncOption(option)
-}
-
-/// Polls a future until the result is available.
-pub fn block_on<O>(task: impl core::future::Future<Output = O>) -> O {
-    let mut task: crate::bb02_async::Task<O> = alloc::boxed::Box::pin(task);
-    loop {
-        bitbox02::ui::screen_process();
-        if let Poll::Ready(result) = spin(&mut task) {
-            return result;
-        }
-    }
-}

src/rust/bitbox02-rust/src/hww.rs

@@ -136,10 +136,10 @@ mod tests {
     use super::*;
     extern crate std;
 
-    use crate::bb02_async::block_on;
     use crate::hal::testing::TestingHal;
     use crate::workflow::testing::Screen;
     use bitbox02::testing::mock_memory;
+    use util::bb02_async::block_on;
 
     use prost::Message;
 

src/rust/bitbox02-rust/src/hww/api/backup.rs

@@ -162,11 +162,11 @@ pub fn list(hal: &mut impl crate::hal::Hal) -> Result<Response, Error> {
 mod tests {
     use super::*;
 
-    use crate::bb02_async::block_on;
     use crate::hal::testing::TestingHal;
     use crate::workflow::testing::Screen;
     use alloc::boxed::Box;
     use bitbox02::testing::{mock_memory, mock_unlocked, mock_unlocked_using_mnemonic};
+    use util::bb02_async::block_on;
 
     /// Test backup creation on a uninitialized keystore.
     #[test]

src/rust/bitbox02-rust/src/hww/api/bitcoin.rs

@@ -331,7 +331,6 @@ pub async fn process_api(
 mod tests {
     use super::*;
 
-    use crate::bb02_async::block_on;
     use crate::bip32::parse_xpub;
     use crate::hal::testing::TestingHal;
     use crate::workflow::testing::Screen;
@@ -341,6 +340,7 @@ mod tests {
         TEST_MNEMONIC, mock_memory, mock_unlocked, mock_unlocked_using_mnemonic,
     };
     use pb::btc_script_config::multisig::ScriptType as MultisigScriptType;
+    use util::bb02_async::block_on;
     use util::bip32::HARDENED;
 
     #[test]

src/rust/bitbox02-rust/src/hww/api/bitcoin/signmsg.rs

@@ -140,11 +140,11 @@ pub async fn process(
 mod tests {
     use super::*;
 
-    use crate::bb02_async::block_on;
     use crate::hal::testing::TestingHal;
     use crate::workflow::testing::Screen;
     use alloc::boxed::Box;
     use bitbox02::testing::mock_unlocked;
+    use util::bb02_async::block_on;
     use util::bip32::HARDENED;
 
     const MESSAGE: &str = "message";

src/rust/bitbox02-rust/src/hww/api/bitcoin/signtx.rs

@@ -1273,13 +1273,13 @@ pub async fn process(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::bb02_async::block_on;
     use crate::bip32::parse_xpub;
     use crate::hal::testing::TestingHal;
     use crate::workflow::testing::Screen;
     use alloc::boxed::Box;
     use bitbox02::testing::{mock_memory, mock_unlocked, mock_unlocked_using_mnemonic};
     use pb::btc_payment_request_request::{Memo, memo};
+    use util::bb02_async::block_on;
     use util::bip32::HARDENED;
 
     fn extract_next(response: &Response) -> &pb::BtcSignNextResponse {

src/rust/bitbox02-rust/src/hww/api/bitcoin/xpubs.rs

@@ -68,8 +68,8 @@ pub async fn process_xpubs(request: &pb::BtcXpubsRequest) -> Result<Response, Er
 mod tests {
     use super::*;
 
-    use crate::bb02_async::block_on;
     use bitbox02::testing::{mock_memory, mock_unlocked, mock_unlocked_using_mnemonic};
+    use util::bb02_async::block_on;
     use util::bip32::HARDENED;
 
     #[test]