Connection fd callback before actual connection (#5494)

.github/workflows/ci-build-ts.yml

@@ -19,7 +19,7 @@ jobs:
     - uses: rlespinasse/github-slug-action@v3.x
     - uses: actions/setup-node@v4
       with:
-        node-version: 20
+        node-version: 18
     - name: Setup yarn
       run: npm install -g yarn
     - name: Build

.github/workflows/ci-lint-typescript.yml

@@ -10,7 +10,7 @@ on:
       - "nym-connect/desktop/package.json"
       - "nym-wallet/src/**"
       - "nym-wallet/package.json"
-      - "explorer-nextjs/src/**"
+      - "explorer/**"
       - ".github/workflows/ci-lint-typescript.yml"
 
 jobs:
@@ -22,7 +22,7 @@ jobs:
 
       - uses: actions/setup-node@v4
         with:
-          node-version: 20
+          node-version: 18
       - name: Setup yarn
         run: npm install -g yarn
 
@@ -37,12 +37,12 @@ jobs:
       - name: Install wasm-opt
         uses: ./.github/actions/install-wasm-opt
         with:
-          version: "116"
+          version: '116'
 
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
-          go-version: "1.20"
+          go-version: '1.20'
 
       - name: Install
         run: yarn

.github/workflows/ci-nym-network-explorer.yml

@@ -4,8 +4,8 @@ on:
   workflow_dispatch:
   push:
     paths:
-      - "explorer/**"
-      - ".github/workflows/ci-nym-network-explorer.yml"
+      - 'explorer/**'
+      - '.github/workflows/ci-nym-network-explorer.yml'
 
 defaults:
   run:
@@ -15,78 +15,78 @@ jobs:
   build:
     runs-on: custom-linux
     steps:
-      - uses: actions/checkout@v4
-      - name: Install rsync
-        run: sudo apt-get install rsync
-        continue-on-error: true
-      - uses: rlespinasse/github-slug-action@v3.x
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-      - name: Setup yarn
-        run: npm install -g yarn
-        continue-on-error: true
-      - name: Build shared packages
-        run: cd .. && yarn && yarn build
-      - name: Set environment from the example
-        run: cp .env.prod .env
-      #    - run: yarn test
-      #      continue-on-error: true
-      - run: yarn && yarn build
-        continue-on-error: true
-      - run: yarn storybook:build
-        name: Build storybook
-      - name: Deploy branch to CI www
-        continue-on-error: true
-        uses: easingthemes/ssh-deploy@main
-        env:
-          SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
-          ARGS: "-rltgoDzvO --delete"
-          SOURCE: "explorer/dist/"
-          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
-          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
-          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/network-explorer-${{ env.GITHUB_REF_SLUG }}
-          EXCLUDE: "/dist/, /node_modules/"
-      - name: Deploy storybook to CI www
-        continue-on-error: true
-        uses: easingthemes/ssh-deploy@main
-        env:
-          SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
-          ARGS: "-rltgoDzvO --delete"
-          SOURCE: "explorer/storybook-static/"
-          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
-          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
-          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/ne-sb-${{ env.GITHUB_REF_SLUG }}
-          EXCLUDE: "/dist/, /node_modules/"
-      - name: Matrix - Node Install
-        run: npm install
-        working-directory: .github/workflows/support-files
-      - name: Matrix - Send Notification
-        env:
-          NYM_NOTIFICATION_KIND: network-explorer
-          NYM_PROJECT_NAME: "Network Explorer"
-          NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
-          NYM_CI_WWW_LOCATION: "network-explorer-${{ env.GITHUB_REF_SLUG }}"
-          NYM_CI_WWW_LOCATION_STORYBOOK: "ne-sb-${{ env.GITHUB_REF_SLUG }}"
-          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
-          GIT_BRANCH: "${GITHUB_REF##*/}"
-          IS_SUCCESS: "${{ job.status == 'success' }}"
-          MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
-          MATRIX_ROOM: "${{ secrets.MATRIX_ROOM }}"
-          MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
-          MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
-          MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
-        uses: docker://keybaseio/client:stable-node
-        with:
-          args: .github/workflows/support-files/notifications/entry_point.sh
-      - name: Deploy
-        if: github.event_name == 'workflow_dispatch'
-        uses: easingthemes/ssh-deploy@main
-        env:
-          SSH_PRIVATE_KEY: ${{ secrets.CD_PROD_NE_SSH_PRIVATE_KEY }}
-          ARGS: "-rltgoDzvO --delete"
-          SOURCE: "explorer/dist/"
-          REMOTE_HOST: ${{ secrets.CD_PROD_NE_REMOTE_HOST }}
-          REMOTE_USER: ${{ secrets.CD_PROD_NE_REMOTE_USER }}
-          TARGET: ${{ secrets.CD_PROD_NE_REMOTE_TARGET }}
-          EXCLUDE: "/dist/, /node_modules/"
+    - uses: actions/checkout@v4
+    - name: Install rsync
+      run: sudo apt-get install rsync
+      continue-on-error: true
+    - uses: rlespinasse/github-slug-action@v3.x
+    - uses: actions/setup-node@v4
+      with:
+        node-version: 18
+    - name: Setup yarn
+      run: npm install -g yarn
+      continue-on-error: true
+    - name: Build shared packages
+      run: cd .. && yarn && yarn build
+    - name: Set environment from the example
+      run: cp .env.prod .env
+#    - run: yarn test
+#      continue-on-error: true
+    - run: yarn && yarn build
+      continue-on-error: true
+    - run: yarn storybook:build
+      name: Build storybook
+    - name: Deploy branch to CI www
+      continue-on-error: true
+      uses: easingthemes/ssh-deploy@main
+      env:
+        SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
+        ARGS: "-rltgoDzvO --delete"
+        SOURCE: "explorer/dist/"
+        REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
+        REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
+        TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/network-explorer-${{ env.GITHUB_REF_SLUG }}
+        EXCLUDE: "/dist/, /node_modules/"
+    - name: Deploy storybook to CI www
+      continue-on-error: true
+      uses: easingthemes/ssh-deploy@main
+      env:
+        SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
+        ARGS: "-rltgoDzvO --delete"
+        SOURCE: "explorer/storybook-static/"
+        REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
+        REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
+        TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/ne-sb-${{ env.GITHUB_REF_SLUG }}
+        EXCLUDE: "/dist/, /node_modules/"
+    - name: Matrix - Node Install
+      run: npm install
+      working-directory: .github/workflows/support-files
+    - name: Matrix - Send Notification
+      env:
+        NYM_NOTIFICATION_KIND: network-explorer
+        NYM_PROJECT_NAME: "Network Explorer"
+        NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
+        NYM_CI_WWW_LOCATION: "network-explorer-${{ env.GITHUB_REF_SLUG }}"
+        NYM_CI_WWW_LOCATION_STORYBOOK: "ne-sb-${{ env.GITHUB_REF_SLUG }}"
+        GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
+        GIT_BRANCH: "${GITHUB_REF##*/}"
+        IS_SUCCESS: "${{ job.status == 'success' }}"
+        MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
+        MATRIX_ROOM: "${{ secrets.MATRIX_ROOM }}"
+        MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
+        MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
+        MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
+      uses: docker://keybaseio/client:stable-node
+      with:
+        args: .github/workflows/support-files/notifications/entry_point.sh
+    - name: Deploy
+      if: github.event_name == 'workflow_dispatch'
+      uses: easingthemes/ssh-deploy@main
+      env:
+        SSH_PRIVATE_KEY: ${{ secrets.CD_PROD_NE_SSH_PRIVATE_KEY }}
+        ARGS: "-rltgoDzvO --delete"
+        SOURCE: "explorer/dist/"
+        REMOTE_HOST: ${{ secrets.CD_PROD_NE_REMOTE_HOST }}
+        REMOTE_USER: ${{ secrets.CD_PROD_NE_REMOTE_USER }}
+        TARGET: ${{ secrets.CD_PROD_NE_REMOTE_TARGET }}
+        EXCLUDE: "/dist/, /node_modules/"

.github/workflows/ci-nym-wallet-storybook.yml

@@ -20,7 +20,7 @@ jobs:
 
     - uses: actions/setup-node@v4
       with:
-        node-version: 20
+        node-version: 18
 
     - name: Setup yarn
       run: npm install -g yarn

Cargo.toml

@@ -322,7 +322,7 @@ serde_with = "3.9.0"
 serde_yaml = "0.9.25"
 sha2 = "0.10.8"
 si-scale = "0.2.3"
-sphinx-packet = "0.3.1"
+sphinx-packet = "0.1.1"
 sqlx = "0.7.4"
 strum = "0.26"
 strum_macros = "0.26"
@@ -330,7 +330,7 @@ subtle-encoding = "0.5"
 syn = "1"
 sysinfo = "0.33.0"
 tap = "1.0.1"
-tar = "0.4.44"
+tar = "0.4.43"
 tempfile = "3.15"
 thiserror = "2.0"
 time = "0.3.37"

clients/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.48"
+version = "1.1.49"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"

clients/socks5/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.48"
+version = "1.1.49"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 description = "A SOCKS5 localhost proxy that converts incoming messages to Sphinx and sends them to a Nym address"
 edition = "2021"

common/bandwidth-controller/src/lib.rs

@@ -105,26 +105,24 @@ impl<C, St: Storage> BandwidthController<C, St> {
     async fn get_aggregate_verification_key(
         &self,
         epoch_id: EpochId,
-        apis: &mut ApiClientsWrapper,
+        ecash_apis: &mut ApiClientsWrapper<'_, C>,
     ) -> Result<VerificationKeyAuth, BandwidthControllerError>
     where
         C: DkgQueryClient + Sync + Send,
         <St as Storage>::StorageError: Send + Sync + 'static,
     {
-        let ecash_apis = apis.get_or_init(epoch_id, &self.client).await?;
         get_aggregate_verification_key(&self.storage, epoch_id, ecash_apis).await
     }
 
     async fn get_coin_index_signatures(
         &self,
         epoch_id: EpochId,
-        apis: &mut ApiClientsWrapper,
+        ecash_apis: &mut ApiClientsWrapper<'_, C>,
     ) -> Result<Vec<AnnotatedCoinIndexSignature>, BandwidthControllerError>
     where
         C: DkgQueryClient + Sync + Send,
         <St as Storage>::StorageError: Send + Sync + 'static,
     {
-        let ecash_apis = apis.get_or_init(epoch_id, &self.client).await?;
         get_coin_index_signatures(&self.storage, epoch_id, ecash_apis).await
     }
 
@@ -132,13 +130,12 @@ impl<C, St: Storage> BandwidthController<C, St> {
         &self,
         epoch_id: EpochId,
         expiration_date: Date,
-        apis: &mut ApiClientsWrapper,
+        ecash_apis: &mut ApiClientsWrapper<'_, C>,
     ) -> Result<Vec<AnnotatedExpirationDateSignature>, BandwidthControllerError>
     where
         C: DkgQueryClient + Sync + Send,
         <St as Storage>::StorageError: Send + Sync + 'static,
     {
-        let ecash_apis = apis.get_or_init(epoch_id, &self.client).await?;
         get_expiration_date_signatures(&self.storage, epoch_id, expiration_date, ecash_apis).await
     }
 
@@ -154,7 +151,7 @@ impl<C, St: Storage> BandwidthController<C, St> {
     {
         let epoch_id = retrieved_ticketbook.ticketbook.epoch_id();
         let expiration_date = retrieved_ticketbook.ticketbook.expiration_date();
-        let mut api_clients = Default::default();
+        let mut api_clients = ApiClientsWrapper::new(&self.client, epoch_id);
 
         let verification_key = self
             .get_aggregate_verification_key(epoch_id, &mut api_clients)

common/bandwidth-controller/src/utils.rs

@@ -21,30 +21,67 @@ use rand::thread_rng;
 use std::fmt::Display;
 use std::future::Future;
 
-// it really doesn't need the RwLock because it's never moved across tasks,
-// but we need all the Send/Sync action
-#[derive(Default)]
-pub(crate) struct ApiClientsWrapper(Option<Vec<EcashApiClient>>);
-
-impl ApiClientsWrapper {
-    pub(crate) async fn get_or_init<C>(
+pub(crate) trait EcashClientsProvider {
+    async fn try_get_ecash_clients(
         &mut self,
+    ) -> Result<Vec<EcashApiClient>, BandwidthControllerError>;
+}
+
+impl EcashClientsProvider for Vec<EcashApiClient> {
+    async fn try_get_ecash_clients(
+        &mut self,
+    ) -> Result<Vec<EcashApiClient>, BandwidthControllerError> {
+        Ok(self.clone())
+    }
+}
+
+impl<C> EcashClientsProvider for &mut ApiClientsWrapper<'_, C>
+where
+    C: DkgQueryClient + Sync + Send,
+{
+    async fn try_get_ecash_clients(
+        &mut self,
+    ) -> Result<Vec<EcashApiClient>, BandwidthControllerError> {
+        self.clients().await
+    }
+}
+
+pub(crate) enum ApiClientsWrapper<'a, C> {
+    Uninitialised {
+        query_client: &'a C,
         epoch_id: EpochId,
-        dkg_client: &C,
-    ) -> Result<Vec<EcashApiClient>, BandwidthControllerError>
+    },
+    Cached {
+        clients: Vec<EcashApiClient>,
+    },
+}
+
+impl<'a, C> ApiClientsWrapper<'a, C> {
+    pub(crate) fn new(query_client: &'a C, epoch_id: EpochId) -> Self {
+        ApiClientsWrapper::Uninitialised {
+            query_client,
+            epoch_id,
+        }
+    }
+
+    async fn clients(&mut self) -> Result<Vec<EcashApiClient>, BandwidthControllerError>
     where
         C: DkgQueryClient + Sync + Send,
     {
-        if let Some(cached) = &self.0 {
-            return Ok(cached.clone());
+        match self {
+            ApiClientsWrapper::Uninitialised {
+                query_client,
+                epoch_id,
+            } => {
+                let clients = all_ecash_api_clients(*query_client, *epoch_id).await?;
+                *self = ApiClientsWrapper::Cached {
+                    clients: clients.clone(),
+                };
+
+                Ok(clients)
+            }
+            ApiClientsWrapper::Cached { clients } => Ok(clients.clone()),
         }
-
-        let clients = all_ecash_api_clients(dkg_client, epoch_id).await?;
-
-        // technically we don't have to be cloning all the clients here, but it's way simpler than
-        // dealing with locking and whatnot given the performance penalty is negligible
-        self.0 = Some(clients.clone());
-        Ok(clients)
     }
 }
 
@@ -76,7 +113,7 @@ where
 pub(crate) async fn get_aggregate_verification_key<St>(
     storage: &St,
     epoch_id: EpochId,
-    ecash_apis: Vec<EcashApiClient>,
+    mut ecash_apis: impl EcashClientsProvider,
 ) -> Result<VerificationKeyAuth, BandwidthControllerError>
 where
     St: Storage,
@@ -90,6 +127,8 @@ where
         return Ok(stored);
     };
 
+    let ecash_apis = ecash_apis.try_get_ecash_clients().await?;
+
     let master_vk = query_random_apis_until_success(
         ecash_apis,
         |api| async move { api.api_client.master_verification_key(Some(epoch_id)).await },
@@ -115,7 +154,7 @@ where
 pub(crate) async fn get_coin_index_signatures<St>(
     storage: &St,
     epoch_id: EpochId,
-    ecash_apis: Vec<EcashApiClient>,
+    mut ecash_apis: impl EcashClientsProvider,
 ) -> Result<Vec<AnnotatedCoinIndexSignature>, BandwidthControllerError>
 where
     St: Storage,
@@ -129,6 +168,8 @@ where
         return Ok(stored);
     };
 
+    let ecash_apis = ecash_apis.try_get_ecash_clients().await?;
+
     let index_sigs = query_random_apis_until_success(
         ecash_apis,
         |api| async move {
@@ -159,7 +200,7 @@ pub(crate) async fn get_expiration_date_signatures<St>(
     storage: &St,
     epoch_id: EpochId,
     expiration_date: Date,
-    ecash_apis: Vec<EcashApiClient>,
+    mut ecash_apis: impl EcashClientsProvider,
 ) -> Result<Vec<AnnotatedExpirationDateSignature>, BandwidthControllerError>
 where
     St: Storage,
@@ -173,6 +214,8 @@ where
         return Ok(stored);
     };
 
+    let ecash_apis = ecash_apis.try_get_ecash_clients().await?;
+
     let expiration_sigs = query_random_apis_until_success(
         ecash_apis,
         |api| async move {

common/crypto/Cargo.toml

@@ -37,10 +37,11 @@ nym-pemstore = { path = "../../common/pemstore", version = "0.3.0" }
 rand_chacha = { workspace = true }
 
 [features]
-default = []
+default = ["sphinx"]
 aead = ["dep:aead", "aead/std", "aes-gcm-siv", "generic-array"]
 serde = ["dep:serde", "serde_bytes", "ed25519-dalek/serde", "x25519-dalek/serde"]
 asymmetric = ["x25519-dalek", "ed25519-dalek", "zeroize"]
 hashing = ["blake3", "digest", "hkdf", "hmac", "generic-array", "sha2"]
 stream_cipher = ["aes", "ctr", "cipher", "generic-array"]
-sphinx = ["nym-sphinx-types/sphinx"]
+sphinx = ["nym-sphinx-types/sphinx"]
+outfox = ["nym-sphinx-types/outfox"]

common/crypto/src/asymmetric/encryption/mod.rs

@@ -202,18 +202,6 @@ impl PemStorableKey for PublicKey {
     }
 }
 
-impl From<x25519_dalek::PublicKey> for PublicKey {
-    fn from(public_key: x25519_dalek::PublicKey) -> Self {
-        PublicKey(public_key)
-    }
-}
-
-impl From<PublicKey> for x25519_dalek::PublicKey {
-    fn from(public_key: PublicKey) -> Self {
-        public_key.0
-    }
-}
-
 #[derive(Zeroize, ZeroizeOnDrop)]
 pub struct PrivateKey(x25519_dalek::StaticSecret);
 
@@ -320,15 +308,109 @@ impl PemStorableKey for PrivateKey {
     }
 }
 
-impl From<x25519_dalek::StaticSecret> for PrivateKey {
-    fn from(secret: x25519_dalek::StaticSecret) -> Self {
-        PrivateKey(secret)
+// compatibility with sphinx keys:
+#[cfg(feature = "sphinx")]
+impl From<PublicKey> for nym_sphinx_types::PublicKey {
+    fn from(key: PublicKey) -> Self {
+        nym_sphinx_types::PublicKey::from(key.to_bytes())
     }
 }
 
-impl AsRef<x25519_dalek::StaticSecret> for PrivateKey {
-    fn as_ref(&self) -> &x25519_dalek::StaticSecret {
-        &self.0
+#[cfg(feature = "sphinx")]
+impl<'a> From<&'a PublicKey> for nym_sphinx_types::PublicKey {
+    fn from(key: &'a PublicKey) -> Self {
+        nym_sphinx_types::PublicKey::from((*key).to_bytes())
+    }
+}
+
+#[cfg(feature = "sphinx")]
+impl From<nym_sphinx_types::PublicKey> for PublicKey {
+    fn from(pub_key: nym_sphinx_types::PublicKey) -> Self {
+        Self(x25519_dalek::PublicKey::from(*pub_key.as_bytes()))
+    }
+}
+
+#[cfg(feature = "sphinx")]
+impl From<PrivateKey> for nym_sphinx_types::PrivateKey {
+    fn from(key: PrivateKey) -> Self {
+        nym_sphinx_types::PrivateKey::from(key.to_bytes())
+    }
+}
+
+#[cfg(feature = "sphinx")]
+impl<'a> From<&'a PrivateKey> for nym_sphinx_types::PrivateKey {
+    fn from(key: &'a PrivateKey) -> Self {
+        nym_sphinx_types::PrivateKey::from(key.to_bytes())
+    }
+}
+
+#[cfg(feature = "sphinx")]
+impl From<nym_sphinx_types::PrivateKey> for PrivateKey {
+    fn from(private_key: nym_sphinx_types::PrivateKey) -> Self {
+        let private_key_bytes = private_key.to_bytes();
+        assert_eq!(private_key_bytes.len(), PRIVATE_KEY_SIZE);
+        Self::from_bytes(&private_key_bytes).unwrap()
+    }
+}
+
+#[cfg(test)]
+mod sphinx_key_conversion {
+    use super::*;
+    use rand_chacha::rand_core::SeedableRng;
+    use rand_chacha::ChaCha20Rng;
+
+    pub(super) fn test_rng() -> ChaCha20Rng {
+        let dummy_seed = [42u8; 32];
+        ChaCha20Rng::from_seed(dummy_seed)
+    }
+
+    const NUM_ITERATIONS: usize = 100;
+
+    #[test]
+    fn works_for_forward_conversion() {
+        let mut rng = test_rng();
+
+        for _ in 0..NUM_ITERATIONS {
+            let keys = KeyPair::new(&mut rng);
+            let private = &keys.private_key;
+            let public = &keys.public_key;
+
+            let dummy_remote = KeyPair::new(&mut rng);
+            let dh1 = private.diffie_hellman(&dummy_remote.public_key);
+
+            let public_bytes = public.to_bytes();
+
+            let sphinx_private: nym_sphinx_types::PrivateKey = private.into();
+            let recovered_private = PrivateKey::from(sphinx_private);
+
+            let dh2 = recovered_private.diffie_hellman(&dummy_remote.public_key);
+
+            let sphinx_public: nym_sphinx_types::PublicKey = public.into();
+            let recovered_public = PublicKey::from(sphinx_public);
+            assert_eq!(public_bytes, recovered_public.to_bytes());
+
+            // even though the byte representation of the private key changed, the resultant DH is the same
+            // which is what matters
+            assert_eq!(dh1, dh2);
+        }
+    }
+
+    #[test]
+    fn works_for_backward_conversion() {
+        for _ in 0..NUM_ITERATIONS {
+            let (sphinx_private, sphinx_public) = nym_sphinx_types::crypto::keygen();
+
+            let private_bytes = sphinx_private.to_bytes();
+            let public_bytes = sphinx_public.as_bytes();
+
+            let private: PrivateKey = sphinx_private.into();
+            let recovered_sphinx_private: nym_sphinx_types::PrivateKey = private.into();
+
+            let public: PublicKey = sphinx_public.into();
+            let recovered_sphinx_public: nym_sphinx_types::PublicKey = public.into();
+            assert_eq!(private_bytes, recovered_sphinx_private.to_bytes());
+            assert_eq!(public_bytes, recovered_sphinx_public.as_bytes());
+        }
     }
 }
 

common/http-api-common/Cargo.toml

@@ -20,7 +20,6 @@ mime = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json.workspace = true
 serde_yaml = { workspace = true }
-subtle.workspace = true
 tower = { workspace = true }
 tracing.workspace = true
 utoipa = { workspace = true, optional = true }

common/http-api-common/src/middleware/bearer_auth.rs

@@ -7,7 +7,6 @@ use axum::{extract::Request, response::Response};
 use futures::future::BoxFuture;
 use std::sync::Arc;
 use std::task::{Context, Poll};
-use subtle::ConstantTimeEq;
 use tower::{Layer, Service};
 use tracing::{debug, instrument, trace};
 use zeroize::Zeroizing;
@@ -77,7 +76,7 @@ impl<S> RequireAuth<S> {
             return Err("`Authorization` header must contain non-empty `Bearer` token");
         }
 
-        if bool::from(self.bearer_token.as_bytes().ct_ne(bearer_token.as_bytes())) {
+        if self.bearer_token.as_str() != bearer_token {
             return Err("`Authorization` header does not contain the correct `Bearer` token");
         }
 

common/nymsphinx/Cargo.toml

@@ -48,10 +48,12 @@ features = ["sync"]
 [features]
 default = ["sphinx"]
 sphinx = [
+    "nym-crypto/sphinx",
     "nym-sphinx-params/sphinx",
     "nym-sphinx-types/sphinx",
 ]
 outfox = [
+    "nym-crypto/outfox",
     "nym-sphinx-params/outfox",
     "nym-sphinx-types/outfox",
 ]

common/nymsphinx/addressing/Cargo.toml

@@ -8,7 +8,7 @@ license = { workspace = true }
 repository = { workspace = true }
 
 [dependencies]
-nym-crypto = { path = "../../crypto", features = ["asymmetric", "sphinx"] } # all addresses are expressed in terms on their crypto keys
+nym-crypto = { path = "../../crypto", features = ["asymmetric"] } # all addresses are expressed in terms on their crypto keys
 nym-sphinx-types = { path = "../types", features = ["sphinx"] } # we need to be able to refer to some types defined inside sphinx crate
 serde = { workspace = true } # implementing serialization/deserialization for some types, like `Recipient`
 thiserror = { workspace = true }

common/nymsphinx/anonymous-replies/src/requests.rs

@@ -559,7 +559,7 @@ mod tests {
             let mut address_bytes = [0; NODE_ADDRESS_LENGTH];
             rng.fill_bytes(&mut address_bytes);
 
-            let dummy_private = PrivateKey::random_from_rng(rng);
+            let dummy_private = PrivateKey::new_with_rng(rng);
             let pub_key = (&dummy_private).into();
             Node {
                 address: NodeAddressBytes::from_bytes(address_bytes),

common/nymsphinx/framing/src/codec.rs

@@ -130,33 +130,28 @@ impl Decoder for NymCodec {
 mod packet_encoding {
     use super::*;
     use nym_sphinx_types::{
-        Delay as SphinxDelay, Destination, DestinationAddressBytes, Node, NodeAddressBytes,
-        PrivateKey, DESTINATION_ADDRESS_LENGTH, IDENTIFIER_LENGTH, NODE_ADDRESS_LENGTH,
+        crypto, Delay as SphinxDelay, Destination, DestinationAddressBytes, Node, NodeAddressBytes,
+        DESTINATION_ADDRESS_LENGTH, IDENTIFIER_LENGTH, NODE_ADDRESS_LENGTH,
     };
 
-    fn random_pubkey() -> nym_sphinx_types::PublicKey {
-        let private_key = PrivateKey::random();
-        (&private_key).into()
-    }
-
     fn make_valid_outfox_packet(size: PacketSize) -> NymPacket {
-        let node1_pk = random_pubkey();
+        let (_, node1_pk) = crypto::keygen();
         let node1 = Node::new(
             NodeAddressBytes::from_bytes([5u8; NODE_ADDRESS_LENGTH]),
             node1_pk,
         );
-        let node2_pk = random_pubkey();
+        let (_, node2_pk) = crypto::keygen();
         let node2 = Node::new(
             NodeAddressBytes::from_bytes([4u8; NODE_ADDRESS_LENGTH]),
             node2_pk,
         );
-        let node3_pk = random_pubkey();
+        let (_, node3_pk) = crypto::keygen();
         let node3 = Node::new(
             NodeAddressBytes::from_bytes([2u8; NODE_ADDRESS_LENGTH]),
             node3_pk,
         );
 
-        let node4_pk = random_pubkey();
+        let (_, node4_pk) = crypto::keygen();
         let node4 = Node::new(
             NodeAddressBytes::from_bytes([2u8; NODE_ADDRESS_LENGTH]),
             node4_pk,
@@ -175,17 +170,17 @@ mod packet_encoding {
     }
 
     fn make_valid_sphinx_packet(size: PacketSize) -> NymPacket {
-        let node1_pk = random_pubkey();
+        let (_, node1_pk) = crypto::keygen();
         let node1 = Node::new(
             NodeAddressBytes::from_bytes([5u8; NODE_ADDRESS_LENGTH]),
             node1_pk,
         );
-        let node2_pk = random_pubkey();
+        let (_, node2_pk) = crypto::keygen();
         let node2 = Node::new(
             NodeAddressBytes::from_bytes([4u8; NODE_ADDRESS_LENGTH]),
             node2_pk,
         );
-        let node3_pk = random_pubkey();
+        let (_, node3_pk) = crypto::keygen();
         let node3 = Node::new(
             NodeAddressBytes::from_bytes([2u8; NODE_ADDRESS_LENGTH]),
             node3_pk,

common/nymsphinx/framing/src/processing.rs

@@ -4,10 +4,8 @@ use nym_sphinx_addressing::nodes::{NymNodeRoutingAddress, NymNodeRoutingAddressE
 use nym_sphinx_params::{PacketSize, PacketType};
 use nym_sphinx_types::{
     Delay as SphinxDelay, DestinationAddressBytes, NodeAddressBytes, NymPacket, NymPacketError,
-    NymProcessedPacket, OutfoxError, PrivateKey, ProcessedPacketData, SphinxError,
-    Version as SphinxPacketVersion,
+    NymProcessedPacket, OutfoxError, PrivateKey, ProcessedPacket, SphinxError,
 };
-use std::fmt::Display;
 use thiserror::Error;
 
 use crate::packet::FramedNymPacket;
@@ -15,38 +13,12 @@ use nym_metrics::nanos;
 use nym_sphinx_forwarding::packet::MixPacket;
 
 #[derive(Debug)]
-pub enum MixProcessingResultData {
+pub enum MixProcessingResult {
     /// Contains unwrapped data that should first get delayed before being sent to next hop.
-    ForwardHop {
-        packet: MixPacket,
-        delay: Option<SphinxDelay>,
-    },
+    ForwardHop(MixPacket, Option<SphinxDelay>),
 
     /// Contains all data extracted out of the final hop packet that could be forwarded to the destination.
-    FinalHop { final_hop_data: ProcessedFinalHop },
-}
-
-#[derive(Debug, Copy, Clone)]
-pub enum MixPacketVersion {
-    Outfox,
-    Sphinx(SphinxPacketVersion),
-}
-
-impl Display for MixPacketVersion {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        match self {
-            MixPacketVersion::Outfox => "outfox".fmt(f),
-            MixPacketVersion::Sphinx(sphinx_version) => {
-                write!(f, "sphinx-{}", sphinx_version.value())
-            }
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct MixProcessingResult {
-    pub packet_version: MixPacketVersion,
-    pub processing_data: MixProcessingResultData,
+    FinalHop(ProcessedFinalHop),
 }
 
 type ForwardAck = MixPacket;
@@ -135,63 +107,37 @@ fn perform_final_processing(
 ) -> Result<MixProcessingResult, PacketProcessingError> {
     match packet {
         NymProcessedPacket::Sphinx(packet) => {
-            let processing_data = match packet.data {
-                ProcessedPacketData::ForwardHop {
-                    next_hop_packet,
-                    next_hop_address,
-                    delay,
-                } => process_forward_hop(
-                    NymPacket::Sphinx(next_hop_packet),
-                    next_hop_address,
-                    delay,
-                    packet_type,
-                ),
+            match packet {
+                ProcessedPacket::ForwardHop(packet, address, delay) => {
+                    process_forward_hop(NymPacket::Sphinx(*packet), address, delay, packet_type)
+                }
                 // right now there's no use for the surb_id included in the header - probably it should get removed from the
                 // sphinx all together?
-                ProcessedPacketData::FinalHop {
-                    destination,
-                    identifier: _,
-                    payload,
-                } => process_final_hop(
+                ProcessedPacket::FinalHop(destination, _, payload) => process_final_hop(
                     destination,
                     payload.recover_plaintext()?,
                     packet_size,
                     packet_type,
                 ),
-            }?;
-
-            Ok(MixProcessingResult {
-                packet_version: MixPacketVersion::Sphinx(packet.version),
-                processing_data,
-            })
+            }
         }
         NymProcessedPacket::Outfox(packet) => {
             let next_address = *packet.next_address();
             let packet = packet.into_packet();
             if packet.is_final_hop() {
-                let processing_data = process_final_hop(
+                process_final_hop(
                     DestinationAddressBytes::from_bytes(next_address),
                     packet.recover_plaintext()?.to_vec(),
                     packet_size,
                     packet_type,
-                )?;
-                Ok(MixProcessingResult {
-                    packet_version: MixPacketVersion::Outfox,
-                    processing_data,
-                })
+                )
             } else {
-                let packet = MixPacket::new(
+                let mix_packet = MixPacket::new(
                     NymNodeRoutingAddress::try_from_bytes(&next_address)?,
                     NymPacket::Outfox(packet),
                     PacketType::Outfox,
                 );
-                Ok(MixProcessingResult {
-                    packet_version: MixPacketVersion::Outfox,
-                    processing_data: MixProcessingResultData::ForwardHop {
-                        packet,
-                        delay: None,
-                    },
-                })
+                Ok(MixProcessingResult::ForwardHop(mix_packet, None))
             }
         }
     }
@@ -202,16 +148,14 @@ fn process_final_hop(
     payload: Vec<u8>,
     packet_size: PacketSize,
     packet_type: PacketType,
-) -> Result<MixProcessingResultData, PacketProcessingError> {
+) -> Result<MixProcessingResult, PacketProcessingError> {
     let (forward_ack, message) = split_into_ack_and_message(payload, packet_size, packet_type)?;
 
-    Ok(MixProcessingResultData::FinalHop {
-        final_hop_data: ProcessedFinalHop {
-            destination,
-            forward_ack,
-            message,
-        },
-    })
+    Ok(MixProcessingResult::FinalHop(ProcessedFinalHop {
+        destination,
+        forward_ack,
+        message,
+    }))
 }
 
 fn split_into_ack_and_message(
@@ -267,14 +211,11 @@ fn process_forward_hop(
     forward_address: NodeAddressBytes,
     delay: SphinxDelay,
     packet_type: PacketType,
-) -> Result<MixProcessingResultData, PacketProcessingError> {
+) -> Result<MixProcessingResult, PacketProcessingError> {
     let next_hop_address = NymNodeRoutingAddress::try_from(forward_address)?;
 
-    let packet = MixPacket::new(next_hop_address, packet, packet_type);
-    Ok(MixProcessingResultData::ForwardHop {
-        packet,
-        delay: Some(delay),
-    })
+    let mix_packet = MixPacket::new(next_hop_address, packet, packet_type);
+    Ok(MixProcessingResult::ForwardHop(mix_packet, Some(delay)))
 }
 
 // TODO: what more could we realistically test here?

common/nymsphinx/params/Cargo.toml

@@ -16,5 +16,5 @@ nym-sphinx-types = { path = "../types" }
 
 [features]
 default = ["sphinx"]
-sphinx = ["nym-sphinx-types/outfox"]
-outfox = ["nym-sphinx-types/outfox"]
+sphinx = ["nym-crypto/sphinx", "nym-sphinx-types/outfox"]
+outfox = ["nym-crypto/outfox", "nym-sphinx-types/outfox"]

common/nymsphinx/types/src/lib.rs

@@ -1,22 +1,14 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use std::{array::TryFromSliceError, fmt};
-use thiserror::Error;
-
-#[cfg(feature = "outfox")]
-use nym_outfox::packet::{OutfoxPacket, OutfoxProcessedPacket};
-
-#[cfg(feature = "sphinx")]
-use sphinx_packet::{SphinxPacket, SphinxPacketBuilder};
-
 #[cfg(feature = "outfox")]
 pub use nym_outfox::{
     constants::MIN_PACKET_SIZE, constants::MIX_PARAMS_LEN, constants::OUTFOX_PACKET_OVERHEAD,
     error::OutfoxError,
 };
 // re-exporting types and constants available in sphinx
-
+#[cfg(feature = "outfox")]
+use nym_outfox::packet::{OutfoxPacket, OutfoxProcessedPacket};
 #[cfg(feature = "sphinx")]
 pub use sphinx_packet::{
     constants::{
@@ -29,10 +21,12 @@ pub use sphinx_packet::{
     payload::{Payload, PAYLOAD_OVERHEAD_SIZE},
     route::{Destination, DestinationAddressBytes, Node, NodeAddressBytes, SURBIdentifier},
     surb::{SURBMaterial, SURB},
-    version::Version,
-    version::UPDATED_LEGACY_VERSION,
-    Error as SphinxError, ProcessedPacket, ProcessedPacketData,
+    Error as SphinxError, ProcessedPacket,
 };
+#[cfg(feature = "sphinx")]
+use sphinx_packet::{SphinxPacket, SphinxPacketBuilder};
+use std::{array::TryFromSliceError, fmt};
+use thiserror::Error;
 
 #[derive(Error, Debug)]
 pub enum NymPacketError {
@@ -91,12 +85,8 @@ impl NymPacket {
         destination: &Destination,
         delays: &[Delay],
     ) -> Result<NymPacket, NymPacketError> {
-        // FIXME:
-        // for now explicitly use the legacy version until sufficient number of nodes
-        // understand both variants
         Ok(NymPacket::Sphinx(
             SphinxPacketBuilder::new()
-                .with_version(UPDATED_LEGACY_VERSION)
                 .with_payload_size(size)
                 .build_packet(message, route, destination, delays)?,
         ))

common/topology/Cargo.toml

@@ -27,7 +27,7 @@ wasm-bindgen = { workspace = true, optional = true }
 
 ## internal
 nym-config = { path = "../config" }
-nym-crypto = { path = "../crypto" }
+nym-crypto = { path = "../crypto", features = ["sphinx", "outfox"] }
 nym-mixnet-contract-common = { path = "../cosmwasm-smart-contracts/mixnet-contract" }
 nym-sphinx-addressing = { path = "../nymsphinx/addressing" }
 nym-sphinx-types = { path = "../nymsphinx/types", features = [

common/topology/src/node.rs

@@ -105,7 +105,7 @@ impl<'a> From<&'a RoutingNode> for SphinxNode {
             .try_into()
             .unwrap();
 
-        SphinxNode::new(node_address_bytes, node.sphinx_key.into())
+        SphinxNode::new(node_address_bytes, (&node.sphinx_key).into())
     }
 }
 

documentation/docs/vercel.json

@@ -1,7 +0,0 @@
-{
-  "git": {
-    "deploymentEnabled": {
-      "master": false
-    }
-  }
-}

explorer-api/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "explorer-api"
-version = "1.1.46"
+version = "1.1.47"
 edition = "2021"
 license.workspace = true
 

explorer-nextjs/.eslintrc.json

@@ -1,3 +1,3 @@
 {
-  "extends": ["next/core-web-vitals", "next/typescript"]
+  "extends": ["next/core-web-vitals"]
 }

explorer-nextjs/.gitignore

@@ -3,12 +3,8 @@
 # dependencies
 /node_modules
 /.pnp
-.pnp.*
-.yarn/*
-!.yarn/patches
-!.yarn/plugins
-!.yarn/releases
-!.yarn/versions
+.pnp.js
+.yarn/install-state.gz
 
 # testing
 /coverage
@@ -29,8 +25,8 @@ npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
 
-# env files (can opt-in for committing if needed)
-.env*
+# local env files
+.env*.local
 
 # vercel
 .vercel

explorer-nextjs/README.md

@@ -1,4 +1,4 @@
-This is a [Next.js](https://nextjs.org) project bootstrapped with [`create-next-app`](https://nextjs.org/docs/app/api-reference/cli/create-next-app).
+This is a [Next.js](https://nextjs.org/) project bootstrapped with [`create-next-app`](https://github.com/vercel/next.js/tree/canary/packages/create-next-app).
 
 ## Getting Started
 
@@ -18,7 +18,7 @@ Open [http://localhost:3000](http://localhost:3000) with your browser to see the
 
 You can start editing the page by modifying `app/page.tsx`. The page auto-updates as you edit the file.
 
-This project uses [`next/font`](https://nextjs.org/docs/app/building-your-application/optimizing/fonts) to automatically optimize and load [Geist](https://vercel.com/font), a new font family for Vercel.
+This project uses [`next/font`](https://nextjs.org/docs/basic-features/font-optimization) to automatically optimize and load Inter, a custom Google Font.
 
 ## Learn More
 
@@ -27,10 +27,10 @@ To learn more about Next.js, take a look at the following resources:
 - [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
 - [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.
 
-You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js) - your feedback and contributions are welcome!
+You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js/) - your feedback and contributions are welcome!
 
 ## Deploy on Vercel
 
 The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.
 
-Check out our [Next.js deployment documentation](https://nextjs.org/docs/app/building-your-application/deploying) for more details.
+Check out our [Next.js deployment documentation](https://nextjs.org/docs/deployment) for more details.