wip

Author: mmsinclair

common/client-core/src/client/packet_statistics_control.rs

@@ -3,6 +3,7 @@ use std::{
     time::{Duration, Instant},
 };
 
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
 use nym_metrics::{inc, inc_by};
 use si_scale::helpers::bibytes2;
 
@@ -72,6 +73,11 @@ struct PacketStatistics {
 }
 
 impl PacketStatistics {
+    #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+    fn handle_event(&mut self, event: crate::client::packet_statistics_control::PacketStatisticsEvent) {
+    }
+
+    #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
     fn handle_event(&mut self, event: PacketStatisticsEvent) {
         match event {
             PacketStatisticsEvent::RealPacketSent(packet_size) => {

common/credential-utils/Cargo.toml

@@ -9,7 +9,7 @@ license.workspace = true
 [dependencies]
 log = { workspace = true }
 thiserror = { workspace = true }
-tokio = { workspace = true }
+tokio = { workspace = true, features = ["sync", "time"] }
 time.workspace = true
 
 nym-bandwidth-controller = { path = "../../common/bandwidth-controller" }

common/credentials-interface/Cargo.toml

@@ -18,6 +18,15 @@ strum = { workspace = true, features = ["derive"] }
 time = { workspace = true, features = ["serde"] }
 rand = { workspace = true }
 
+# 'wasm-serde-types' feature
+wasm-utils = { path = "../wasm/utils", default-features = false, optional = true }
+tsify = { workspace = true, features = ["js"], optional = true }
+wasm-bindgen = { workspace = true, optional = true }
+
 nym-compact-ecash = { path = "../nym_offline_compact_ecash" }
 nym-ecash-time = { path = "../ecash-time" }
 nym-network-defaults = { path = "../network-defaults" }
+
+[features]
+default = []
+wasm-serde-types = ["tsify", "wasm-bindgen", "wasm-utils"]

common/credentials-interface/src/lib.rs

@@ -30,6 +30,12 @@ pub use nym_compact_ecash::{
 };
 use nym_ecash_time::{ecash_today, EcashTime};
 
+#[cfg(feature = "wasm-serde-types")]
+use tsify::Tsify;
+
+#[cfg(feature = "wasm-serde-types")]
+use wasm_bindgen::{prelude::wasm_bindgen};
+
 #[derive(Debug, Clone)]
 pub struct CredentialSigningData {
     pub withdrawal_request: WithdrawalRequest,
@@ -233,6 +239,8 @@ impl From<PayInfo> for NymPayInfo {
 )]
 #[serde(rename_all = "kebab-case")]
 #[strum(serialize_all = "kebab-case")]
+#[cfg_attr(feature = "wasm-serde-types", derive(Tsify))]
+#[cfg_attr(feature = "wasm-serde-types", tsify(into_wasm_abi, from_wasm_abi))]
 pub enum TicketType {
     #[default]
     V1MixnetEntry,

sdk/rust/nym-sdk/src/bandwidth/client.rs

@@ -26,11 +26,11 @@ where
     St: Storage,
     <St as Storage>::StorageError: Send + Sync + 'static,
 {
-    pub(crate) fn new(
+    pub fn new(
         network_details: NymNetworkDetails,
         mnemonic: String,
         storage: &'a St,
-        client_id: String,
+        client_id_private_key_base58: String,
         ticketbook_type: TicketType,
     ) -> Result<Self> {
         let nyxd_url = network_details.endpoints[0].nyxd_url.as_str();
@@ -44,7 +44,7 @@ where
         Ok(Self {
             client,
             storage,
-            client_id: client_id.into(),
+            client_id: client_id_private_key_base58.into(),
             ticketbook_type,
         })
     }

wasm/zk-nym-lib/Cargo.toml

@@ -28,10 +28,11 @@ wasm-utils = { path = "../../common/wasm/utils" }
 
 nym-bin-common = { path = "../../common/bin-common" }
 nym-credentials = { path = "../../common/credentials" }
+nym-credential-utils = { path = "../../common/credential-utils" }
 nym-credential-storage = { path = "../../common/credential-storage" }
 nym-bandwidth-controller = { path = "../../common/bandwidth-controller" }
 nym-validator-client = { path = "../../common/client-libs/validator-client", default-features = false }
-nym-credentials-interface = { path = "../../common/credentials-interface" }
+nym-credentials-interface = { path = "../../common/credentials-interface", features = ["wasm-serde-types"]}
 nym-network-defaults = { path = "../../common/network-defaults" }
 
 [dev-dependencies]

wasm/zk-nym-lib/Makefile

@@ -4,4 +4,7 @@ build:
 
 # make my life easier so I wouldn't need to deal with any bundlers. sorry @MS : )
 build-debug-dev:
-	wasm-pack build --scope nymproject --target no-modules
+	wasm-pack build --scope nymproject --target no-modules
+
+clippy:
+	cargo clippy --target wasm32-unknown-unknown -- -Dwarnings

wasm/zk-nym-lib/src/bandwidth.rs

@@ -0,0 +1,62 @@
+// Copyright 2022-2023 - Nym Technologies SA <[email protected]>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::error::WasmCredentialClientError;
+use nym_credential_storage::storage::Storage;
+use nym_credential_utils::utils::issue_credential;
+use nym_credentials_interface::TicketType;
+use nym_network_defaults::NymNetworkDetails;
+use nym_validator_client::{nyxd, DirectSigningReqwestRpcValidatorClient};
+use zeroize::Zeroizing;
+
+/// Represents a client that can be used to acquire bandwidth. You typically create one when you
+/// want to connect to the mixnet using paid coconut bandwidth credentials.
+/// The way to create this client is by calling
+/// [`crate::mixnet::DisconnectedMixnetClient::create_bandwidth_client`] on the associated mixnet
+/// client.
+pub struct BandwidthAcquireClient<'a, St: Storage> {
+    client: DirectSigningReqwestRpcValidatorClient,
+    storage: &'a St,
+    client_id: Zeroizing<String>,
+    ticketbook_type: TicketType,
+}
+
+impl<'a, St> BandwidthAcquireClient<'a, St>
+where
+    St: Storage,
+    <St as Storage>::StorageError: Send + Sync + 'static,
+{
+    pub fn new(
+        network_details: NymNetworkDetails,
+        mnemonic: String,
+        storage: &'a St,
+        client_id_private_key_base58: String,
+        ticketbook_type: TicketType,
+    ) -> Result<Self, WasmCredentialClientError> {
+        let nyxd_url = network_details.endpoints[0].nyxd_url.as_str();
+        let config = nyxd::Config::try_from_nym_network_details(&network_details)?;
+
+        let client = DirectSigningReqwestRpcValidatorClient::connect_with_mnemonic(
+            config,
+            nyxd_url,
+            mnemonic.parse()?,
+        )?;
+        Ok(Self {
+            client,
+            storage,
+            client_id: client_id_private_key_base58.into(),
+            ticketbook_type,
+        })
+    }
+
+    pub async fn acquire(&self) -> Result<(), WasmCredentialClientError> {
+        issue_credential(
+            &self.client,
+            self.storage,
+            self.client_id.as_bytes(),
+            self.ticketbook_type,
+        )
+            .await?;
+        Ok(())
+    }
+}

wasm/zk-nym-lib/src/credential.rs

@@ -5,37 +5,52 @@ use crate::error::WasmCredentialClientError;
 use crate::opts::CredentialClientOpts;
 use js_sys::Promise;
 use nym_credential_storage::ephemeral_storage::EphemeralCredentialStorage;
-use nym_credential_storage::models::StoredIssuedCredential;
+use nym_credential_storage::storage::Storage;
+use nym_credentials_interface::TicketType;
 use nym_network_defaults::NymNetworkDetails;
-use nym_validator_client::nyxd::{Config, CosmWasmCoin};
-use nym_validator_client::DirectSigningReqwestRpcNyxdClient;
+use crate::bandwidth::BandwidthAcquireClient;
+use nym_validator_client::nyxd::CosmWasmCoin;
 use serde::{Deserialize, Serialize};
 use tsify::Tsify;
 use wasm_bindgen::prelude::*;
 use wasm_bindgen_futures::future_to_promise;
-use wasm_utils::console_log;
 use wasm_utils::error::PromisableResult;
 use zeroize::{Zeroize, ZeroizeOnDrop};
+use nym_credentials::ecash::bandwidth::serialiser::VersionedSerialise;
 
 #[wasm_bindgen(js_name = acquireCredential)]
-pub fn acquire_credential(mnemonic: String, amount: String, opts: CredentialClientOpts) -> Promise {
+pub fn acquire_credential(
+    mnemonic: String,
+    amount: String,
+    client_id_private_key_base58: String,
+    ticketbook_type: TicketType,
+    opts: CredentialClientOpts,
+) -> Promise {
     future_to_promise(async move {
-        acquire_credential_async(mnemonic, amount, opts)
-            .await
-            .map(|credential| {
-                serde_wasm_bindgen::to_value(&credential).expect("this serialization can't fail")
-            })
-            .into_promise_result()
+        acquire_credential_async(
+            mnemonic,
+            amount,
+            client_id_private_key_base58,
+            ticketbook_type,
+            opts,
+        )
+        .await
+        .map(|credential| {
+            serde_wasm_bindgen::to_value(&credential).expect("this serialization can't fail")
+        })
+        .into_promise_result()
     })
 }
 
 async fn acquire_credential_async(
     mnemonic: String,
     amount: String,
+    client_id_private_key_base58: String,
+    ticketbook_type: TicketType,
     opts: CredentialClientOpts,
 ) -> Result<WasmIssuedCredential, WasmCredentialClientError> {
-    // start by parsing mnemonic so that we could immediately move it into a Zeroizing wrapper
-    let mnemonic = crate::helpers::parse_mnemonic(mnemonic)?;
+    // // start by parsing mnemonic so that we could immediately move it into a Zeroizing wrapper
+    // let mnemonic = crate::helpers::parse_mnemonic(mnemonic)?;
 
     // why are we parsing into CosmWasmCoin and not "our" Coin?
     // simple. because it has the nicest 'FromStr' impl
@@ -61,44 +76,64 @@ async fn acquire_credential_async(
         }
     };
 
-    let config = Config::try_from_nym_network_details(&network)?;
-
-    // just get the first nyxd endpoint
-    let nyxd_endpoint = network
-        .endpoints
-        .get(0)
-        .ok_or(WasmCredentialClientError::NoNyxdEndpoints)?
-        .try_nyxd_url()?;
-
-    let client = DirectSigningReqwestRpcNyxdClient::connect_reqwest_with_mnemonic(
-        config,
-        nyxd_endpoint,
-        mnemonic,
-    );
-
-    console_log!("starting the deposit...");
-    let deposit_state = nym_bandwidth_controller::acquire::deposit(&client, amount).await?;
-    let blinded_serial = deposit_state.voucher.blinded_serial_number_bs58();
-    console_log!(
-        "obtained bandwidth voucher with the following blinded serial number: {blinded_serial}"
-    );
-
-    // TODO: use proper persistent storage here. probably indexeddb like we have for our 'normal' wasm client
     let ephemeral_storage = EphemeralCredentialStorage::default();
 
-    // store credential in the ephemeral storage...
-    nym_bandwidth_controller::acquire::get_bandwidth_voucher(
-        &deposit_state,
-        &client,
+    let client = BandwidthAcquireClient::new(
+        network,
+        mnemonic,
         &ephemeral_storage,
-    )
-    .await?;
-
-    // and immediately get it out!
-    let mut credentials = ephemeral_storage.take_credentials().await;
-    let cred = credentials.pop().expect("we just got a credential issued");
-
-    Ok(cred.into())
+        client_id_private_key_base58,
+        ticketbook_type,
+    )?;
+
+    client.acquire().await?;
+
+    // let config = Config::try_from_nym_network_details(&network)?;
+    //
+    // // just get the first nyxd endpoint
+    // let nyxd_endpoint = network
+    //     .endpoints
+    //     .get(0)
+    //     .ok_or(WasmCredentialClientError::NoNyxdEndpoints)?
+    //     .try_nyxd_url()?;
+    //
+    // let client = DirectSigningReqwestRpcNyxdClient::connect_reqwest_with_mnemonic(
+    //     config,
+    //     nyxd_endpoint,
+    //     mnemonic,
+    // );
+    //
+    // console_log!("starting the deposit...");
+    // let deposit_state = nym_bandwidth_controller::acquire::deposit(&client, amount).await?;
+    // let blinded_serial = deposit_state.voucher.blinded_serial_number_bs58();
+    // console_log!(
+    //     "obtained bandwidth voucher with the following blinded serial number: {blinded_serial}"
+    // );
+    //
+    // // TODO: use proper persistent storage here. probably indexeddb like we have for our 'normal' wasm client
+    // let ephemeral_storage = EphemeralCredentialStorage::default();
+    //
+    // // store credential in the ephemeral storage...
+    // nym_bandwidth_controller::acquire::get_bandwidth_voucher(
+    //     &deposit_state,
+    //     &client,
+    //     &ephemeral_storage,
+    // )
+    // .await?;
+    //
+
+    match ephemeral_storage.get_next_unspent_usable_ticketbook(1u32).await? {
+        Some(ticket_book) => {
+            let serialized = ticket_book.ticketbook.pack();
+
+            Ok(WasmIssuedCredential {
+                serialization_revision: serialized.revision,
+                credential_data: serialized.data,
+                ticketbook_type: format!("{}", ticketbook_type),
+            })
+        },
+        None => Err(WasmCredentialClientError::TicketbookCredentialStoreIsNone),
+    }
 }
 
 #[derive(Tsify, Debug, Clone, Serialize, Deserialize, Zeroize, ZeroizeOnDrop)]
@@ -107,17 +142,17 @@ async fn acquire_credential_async(
 pub struct WasmIssuedCredential {
     pub serialization_revision: u8,
     pub credential_data: Vec<u8>,
-    pub credential_type: String,
-    pub epoch_id: u32,
+    pub ticketbook_type: String,
+    // pub epoch_id: u32,
 }
 
-impl From<StoredIssuedCredential> for WasmIssuedCredential {
-    fn from(value: StoredIssuedCredential) -> Self {
-        WasmIssuedCredential {
-            serialization_revision: value.serialization_revision,
-            credential_data: value.credential_data.clone(),
-            credential_type: value.credential_type.clone(),
-            epoch_id: value.epoch_id,
-        }
-    }
-}
+// impl From<StoredIssuedCredential> for WasmIssuedCredential {
+//     fn from(value: StoredIssuedCredential) -> Self {
+//         WasmIssuedCredential {
+//             serialization_revision: value.serialization_revision,
+//             credential_data: value.credential_data.clone(),
+//             ticketbook_type: value.ticketbook_type.clone(),
+//             // epoch_id: value.epoch_id,
+//         }
+//     }
+// }

wasm/zk-nym-lib/src/error.rs

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use nym_bandwidth_controller::error::BandwidthControllerError;
-use nym_network_defaults::UrlParseError;
 use nym_validator_client::nyxd::error::NyxdError;
 use thiserror::Error;
 use wasm_utils::wasm_error;
@@ -55,6 +54,9 @@ pub enum WasmCredentialClientError {
         #[from]
         source: bip39::Error,
     },
+
+    #[error("The ticket book cannot be retrieved from the credential store")]
+    TicketbookCredentialStoreIsNone,
 }
 
 wasm_error!(WasmCredentialClientError);

wasm/zk-nym-lib/src/helpers.rs

@@ -35,5 +35,6 @@ pub(crate) fn minimal_coconut_sandbox() -> NymNetworkDetails {
             ..Default::default()
         },
         explorer_api: None,
+        nym_vpn_api_url: None,
     }
 }