Merge pull request #42 from Foundation-Devices/nix-flake

Nix flake + formatting

Author: icota

.github/workflows/rust.yml

@@ -19,20 +19,22 @@ jobs:
         env:
           GH_TOKEN: ${{ secrets.GH_TOKEN }}
         run: |
-          # Configure git to use gh as a credential helper for https://github.com
           gh auth setup-git
 
+      - name: Setup nix
+        uses: DeterminateSystems/[email protected]
+      
       - name: Check formatting
         env:
           GH_TOKEN: ${{ secrets.GH_TOKEN }}
-        run: cargo fmt --all -- --check
+        run: nix develop --command cargo fmt --all -- --check
 
       - name: Run Clippy (fail on warnings)
         env:
           GH_TOKEN: ${{ secrets.GH_TOKEN }}
-        run: cargo clippy --all-targets --all-features -- -D warnings
+        run: nix develop --command cargo clippy --all-targets --all-features -- -D warnings
 
       - name: Run tests
         env:
           GH_TOKEN: ${{ secrets.GH_TOKEN }}
-        run: cargo test --verbose
+        run: nix develop --command cargo test --verbose

abstracted/src/abstracted/abstract_bluetooth.rs

@@ -1,18 +1,16 @@
-use bc_envelope::prelude::CBOREncodable;
-use bc_envelope::{EnvelopeEncodable, Expression, ResponseBehavior};
-use bc_xid::XIDDocument;
-use gstp::{SealedRequestBehavior, SealedResponseBehavior};
-use {
-    crate::{AbstractEnclave, SecureFrom, SecureTryFrom},
-    anyhow::Result,
-    async_trait::async_trait,
-    bc_components::ARID,
-    bc_envelope::Envelope,
-    gstp::{SealedRequest, SealedResponse},
-    std::time::Duration,
-};
+use std::time::Duration;
 
+use anyhow::Result;
+use async_trait::async_trait;
+use bc_components::ARID;
+use bc_envelope::{
+    prelude::CBOREncodable, Envelope, EnvelopeEncodable, Expression, ResponseBehavior,
+};
+use bc_xid::XIDDocument;
 use btp::{chunk, Dechunker};
+use gstp::{SealedRequest, SealedRequestBehavior, SealedResponse, SealedResponseBehavior};
+
+use crate::{AbstractEnclave, SecureFrom, SecureTryFrom};
 
 #[async_trait]
 pub trait AbstractBluetoothChannel {

abstracted/src/abstracted/abstract_enclave.rs

@@ -1,6 +1,8 @@
+use anyhow::Result;
+use bc_components::ARID;
+use bc_envelope::prelude::*;
 use bc_xid::XIDDocument;
 use gstp::{SealedRequest, SealedResponse};
-use {anyhow::Result, bc_components::ARID, bc_envelope::prelude::*};
 
 pub trait AbstractEnclave {
     // Public key operations
@@ -12,7 +14,8 @@ pub trait AbstractEnclave {
     fn sign(&self, envelope: &Envelope) -> Envelope;
     fn seal_response(&self, envelope: &SealedResponse, recipient: &XIDDocument) -> Envelope;
     fn decrypt(&self, envelope: &Envelope) -> Result<Envelope>;
-    //fn unseal(&self, envelope: &Envelope, sender: &XIDDocument) -> Result<Envelope>;
+    //fn unseal(&self, envelope: &Envelope, sender: &XIDDocument) ->
+    // Result<Envelope>;
     fn self_decrypt(&self, envelope: &Envelope) -> Result<Envelope>;
 
     // Request -> Envelope

api-demo/src/demo/bluetooth.rs

@@ -1,15 +1,14 @@
-use {
-    anyhow::Result,
-    async_trait::async_trait,
-    foundation_abstracted::AbstractBluetoothChannel,
-    std::sync::Arc,
-    tokio::{
-        sync::{
-            mpsc::{self, Receiver, Sender},
-            Mutex,
-        },
-        time::{self, Duration},
+use std::sync::Arc;
+
+use anyhow::Result;
+use async_trait::async_trait;
+use foundation_abstracted::AbstractBluetoothChannel;
+use tokio::{
+    sync::{
+        mpsc::{self, Receiver, Sender},
+        Mutex,
     },
+    time::{self, Duration},
 };
 
 #[derive(Debug)]

api-demo/src/demo/enclave.rs

@@ -1,14 +1,11 @@
 #![allow(dead_code)]
 
-use bc_components::{EncapsulationScheme, SignatureScheme};
+use anyhow::Result;
+use bc_components::{EncapsulationScheme, PrivateKeys, PublicKeys, SignatureScheme, ARID};
+use bc_envelope::prelude::*;
 use bc_xid::XIDDocument;
+use foundation_abstracted::AbstractEnclave;
 use gstp::{SealedRequest, SealedResponse};
-use {
-    anyhow::Result,
-    bc_components::{PrivateKeys, PublicKeys, ARID},
-    bc_envelope::prelude::*,
-    foundation_abstracted::AbstractEnclave,
-};
 
 #[derive(Debug)]
 pub struct Enclave {
@@ -65,8 +62,8 @@ impl AbstractEnclave for Enclave {
         envelope.decrypt_to_recipient(&self.private_keys)
     }
 
-    // fn unseal(&self, envelope: &Envelope, sender: &XIDDocument) -> Result<Envelope> {
-    //     envelope.unseal(sender, &self.private_key)
+    // fn unseal(&self, envelope: &Envelope, sender: &XIDDocument) ->
+    // Result<Envelope> {     envelope.unseal(sender, &self.private_key)
     // }
 
     fn self_decrypt(&self, envelope: &Envelope) -> Result<Envelope> {
@@ -122,7 +119,9 @@ impl AbstractEnclave for Enclave {
 
 #[cfg(test)]
 pub mod tests {
-    use {super::*, indoc::indoc};
+    use indoc::indoc;
+
+    use super::*;
 
     #[test]
     fn test_sign() {
@@ -171,8 +170,8 @@ pub mod tests {
     //     let enclave1 = Enclave::new();
     //     let enclave2 = Enclave::new();
     //     let envelope = Envelope::new("Hello, World!");
-    //     let signed_and_encrypted = enclave1.seal(&envelope, enclave2.xid_document());
-    //     assert_eq!(
+    //     let signed_and_encrypted = enclave1.seal(&envelope,
+    // enclave2.xid_document());     assert_eq!(
     //         signed_and_encrypted.format(),
     //         (indoc! {
     //             r#"

api-demo/src/demo/envoy.rs

@@ -1,24 +1,22 @@
+use std::sync::Arc;
+
+use anyhow::{anyhow, bail, Ok, Result};
+use bc_envelope::prelude::*;
 use bc_xid::XIDDocument;
-use foundation_api::api::discovery::Discovery;
-use foundation_api::api::quantum_link::QUANTUM_LINK;
-use foundation_api::quantum_link::QuantumLink;
-
-use foundation_api::api::message::QuantumLinkMessage;
-use foundation_api::fx::ExchangeRate;
-use foundation_api::message::{EnvoyMessage, PassportMessage};
-use foundation_api::pairing::PairingRequest;
+use foundation_abstracted::{AbstractBluetoothChannel, SecureTryFrom};
+use foundation_api::{
+    api::{discovery::Discovery, message::QuantumLinkMessage, quantum_link::QUANTUM_LINK},
+    fx::ExchangeRate,
+    message::{EnvoyMessage, PassportMessage},
+    pairing::PairingRequest,
+    quantum_link::QuantumLink,
+};
 use gstp::{SealedResponse, SealedResponseBehavior};
-use {
-    crate::{
-        chapter_title, latency, paint_broadcast, paint_response, sleep, BluetoothChannel, Camera,
-        Enclave,
-    },
-    anyhow::{anyhow, bail, Ok, Result},
-    bc_envelope::prelude::*,
-    foundation_abstracted::AbstractBluetoothChannel,
-    foundation_abstracted::SecureTryFrom,
-    std::sync::Arc,
-    tokio::{sync::Mutex, task::JoinHandle, time::Duration},
+use tokio::{sync::Mutex, task::JoinHandle, time::Duration};
+
+use crate::{
+    chapter_title, latency, paint_broadcast, paint_response, sleep, BluetoothChannel, Camera,
+    Enclave,
 };
 
 pub const ENVOY_PREFIX: &str = "🔶 Envoy   ";
@@ -119,7 +117,8 @@ impl Envoy {
         envelope: Envelope,
         _stop: Arc<Mutex<bool>>,
     ) -> Result<()> {
-        // TODO: Need code here to determine if it's a SealedResponse, SealedRequest or Event
+        // TODO: Need code here to determine if it's a SealedResponse, SealedRequest or
+        // Event
         let response = SealedResponse::secure_try_from(envelope, &self.enclave)?;
         log!("📡 Received: {}", paint_response!(response));
 

api-demo/src/demo/passport.rs

@@ -1,26 +1,26 @@
+use std::sync::Arc;
+
+use anyhow::{bail, Result};
+use bc_envelope::prelude::*;
 use bc_xid::XIDDocument;
-use foundation_api::api::message::QuantumLinkMessage;
-use foundation_api::api::passport::{PassportFirmwareVersion, PassportSerial};
-use foundation_api::api::quantum_link::QuantumLink;
-use foundation_api::api::quantum_link::QUANTUM_LINK;
-use foundation_api::message::EnvoyMessage;
-use foundation_api::pairing::PairingResponse;
-use foundation_api::passport::{PassportColor, PassportModel};
-use gstp::SealedRequest;
-use gstp::SealedRequestBehavior;
-use {
-    super::{BluetoothChannel, Screen},
-    crate::{chapter_title, latency, paint_broadcast, paint_request, Enclave},
-    anyhow::{bail, Result},
-    bc_envelope::prelude::*,
-    foundation_abstracted::AbstractBluetoothChannel,
-    foundation_abstracted::AbstractEnclave,
-    foundation_abstracted::SecureTryFrom,
-    foundation_api::api::discovery::Discovery,
-    foundation_ur::Encoder,
-    std::sync::Arc,
-    tokio::{sync::Mutex, task::JoinHandle, time::Duration},
+use foundation_abstracted::{AbstractBluetoothChannel, AbstractEnclave, SecureTryFrom};
+use foundation_api::{
+    api::{
+        discovery::Discovery,
+        message::QuantumLinkMessage,
+        passport::{PassportFirmwareVersion, PassportSerial},
+        quantum_link::{QuantumLink, QUANTUM_LINK},
+    },
+    message::EnvoyMessage,
+    pairing::PairingResponse,
+    passport::{PassportColor, PassportModel},
 };
+use foundation_ur::Encoder;
+use gstp::{SealedRequest, SealedRequestBehavior};
+use tokio::{sync::Mutex, task::JoinHandle, time::Duration};
+
+use super::{BluetoothChannel, Screen};
+use crate::{chapter_title, latency, paint_broadcast, paint_request, Enclave};
 
 pub const PASSPORT_PREFIX: &str = "🛂 Passport";
 

api-demo/src/demo/screen.rs

@@ -1,13 +1,12 @@
-use {
-    anyhow::Result,
-    bc_envelope::prelude::*,
-    std::{
-        sync::{Arc, Mutex},
-        time::Duration,
-    },
-    tokio::sync::Notify,
+use std::{
+    sync::{Arc, Mutex},
+    time::Duration,
 };
 
+use anyhow::Result;
+use bc_envelope::prelude::*;
+use tokio::sync::Notify;
+
 #[derive(Debug)]
 pub struct ScreenPeers {
     screen: Arc<Screen>,

api/rustfmt.toml

@@ -1,9 +1,8 @@
-use crate::api::quantum_link::QuantumLink;
 use flutter_rust_bridge::frb;
-use {
-    minicbor_derive::{Decode, Encode},
-    quantum_link_macros::quantum_link,
-};
+use minicbor_derive::{Decode, Encode};
+use quantum_link_macros::quantum_link;
+
+use crate::api::quantum_link::QuantumLink;
 
 #[quantum_link]
 pub struct Shard {