clean status once modal closes

.github/workflows/nightly_build.yml

@@ -75,6 +75,12 @@ jobs:
           command: clippy
           args: --workspace --all-targets -- -D warnings
 
+      - name: Reclaim some disk space (because Windows is being annoying)
+        uses: actions-rs/cargo@v1
+        if: ${{ matrix.os == 'windows-latest' }}
+        with:
+          command: clean
+
       # COCONUT stuff
       - name: Build all binaries with coconut enabled
         uses: actions-rs/cargo@v1
@@ -88,12 +94,6 @@ jobs:
           command: test
           args: --workspace --features=coconut
 
-      - name: Reclaim some disk space (because Windows is being annoying)
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' }}
-        with:
-          command: clean
-
       - name: Run clippy with coconut enabled
         uses: actions-rs/cargo@v1
         if: ${{ matrix.rust != 'nightly' }}

.github/workflows/nym-release-publish.yml

@@ -2,9 +2,6 @@ name: Publish Nym binaries
 on:
   release:
     types: [created]
-    
-env:
-  NETWORK: mainnet    
 
 jobs:
   publish-nym:

Cargo.toml

@@ -18,15 +18,14 @@ members = [
     "clients/native",
     "clients/native/websocket-requests",
     "clients/socks5",
+    # "clients/tauri-client/src-tauri",
     "common/client-libs/gateway-client",
     "common/client-libs/mixnet-client",
     "common/client-libs/validator-client",
-    "common/credential-storage",
     "common/coconut-interface",
     "common/config",
     "common/credentials",
     "common/crypto",
-    "common/crypto/dkg",
     "common/bandwidth-claim-contract",
     "common/cosmwasm-smart-contracts/coconut-bandwidth-contract",
     "common/cosmwasm-smart-contracts/contracts-common",

Makefile

@@ -26,7 +26,7 @@ clippy-all-wallet:
 	cargo clippy --workspace --manifest-path nym-wallet/Cargo.toml --all-features -- -D warnings
 
 test-main:
-	cargo test --all-features --workspace --release
+	cargo test --all-features --workspace
 
 test-contracts:
 	cargo test --manifest-path contracts/Cargo.toml --all-features

README.md

@@ -40,40 +40,36 @@ Node, node operator and delegator rewards are determined according to the princi
 
 |Symbol|Definition|
 |---|---|
-|<img src="https://render.githubusercontent.com/render/math?math=R#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}R#gh-dark-mode-only">|global share of rewards available, starts at 2% of the reward pool.
-|<img src="https://render.githubusercontent.com/render/math?math=R_{i}#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}R_{i}#gh-dark-mode-only">|node reward for mixnode `i`.
-|<img src="https://render.githubusercontent.com/render/math?math=\sigma_{i}#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}\sigma_{i}#gh-dark-mode-only">|ratio of total node stake (node bond + all delegations) to the token circulating supply.
-|<img src="https://render.githubusercontent.com/render/math?math=\lambda_{i}#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}\lambda_{i}#gh-dark-mode-only">|ratio of stake operator has pledged to their node to the token circulating supply.
-|<img src="https://render.githubusercontent.com/render/math?math=\omega_{i}#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}\omega_{i}#gh-dark-mode-only">|fraction of total effort undertaken by node `i`, set to `1/k`.
-|<img src="https://render.githubusercontent.com/render/math?math=k#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}k#gh-dark-mode-only">|number of nodes stakeholders are incentivised to create, set by the validators, a matter of governance. Currently determined by the `reward set` size, and set to 720 in testnet Sandbox.
-|<img src="https://render.githubusercontent.com/render/math?math=\alpha#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}\alpha#gh-dark-mode-only">|Sybil attack resistance parameter - the higher this parameter is set the stronger the reduction in competitivness gets for a Sybil attacker.
-|<img src="https://render.githubusercontent.com/render/math?math=PM_{i}#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}PM_{i}#gh-dark-mode-only">|declared profit margin of operator `i`, defaults to 10% in.
-|<img src="https://render.githubusercontent.com/render/math?math=PF_{i}#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}PF_{i}#gh-dark-mode-only">|uptime of node `i`, scaled to 0 - 1, for the rewarding epoch
-|<img src="https://render.githubusercontent.com/render/math?math=PP_{i}#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}PP_{i}#gh-dark-mode-only">|cost of operating node `i` for the duration of the rewarding epoch, set to 40 NYMT.
+|<img src="https://render.githubusercontent.com/render/math?math=R">|global share of rewards available, starts at 2% of the reward pool. 
+|<img src="https://render.githubusercontent.com/render/math?math=R_{i}">|node reward for mixnode `i`.
+|<img src="https://render.githubusercontent.com/render/math?math=\sigma_{i}">|ratio of total node stake (node bond + all delegations) to the token circulating supply.
+|<img src="https://render.githubusercontent.com/render/math?math=\lambda_{i}">|ratio of stake operator has pledged to their node to the token circulating supply.
+|<img src="https://render.githubusercontent.com/render/math?math=\omega_{i}">|fraction of total effort undertaken by node `i`, set to `1/k`.
+|<img src="https://render.githubusercontent.com/render/math?math=k">|number of nodes stakeholders are incentivised to create, set by the validators, a matter of governance. Currently determined by the `reward set` size, and set to 720 in testnet Sandbox.
+|<img src="https://render.githubusercontent.com/render/math?math=\alpha">|Sybil attack resistance parameter - the higher this parameter is set the stronger the reduction in competitivness gets for a Sybil attacker.
+|<img src="https://render.githubusercontent.com/render/math?math=PM_{i}">|declared profit margin of operator `i`, defaults to 10% in.
+|<img src="https://render.githubusercontent.com/render/math?math=PF_{i}">|uptime of node `i`, scaled to 0 - 1, for the rewarding epoch
+|<img src="https://render.githubusercontent.com/render/math?math=PP_{i}">|cost of operating node `i` for the duration of the rewarding eopoch, set to 40 NYMT.
 
 Node reward for node `i` is determined as:
 
-<img src="https://render.githubusercontent.com/render/math?math=R_{i}=PF_{i} \cdot R \cdot (\sigma^'_{i} \cdot \omega_{i} \cdot k %2b \alpha \cdot \lambda^'_{i} \cdot \sigma^'_{i} \cdot k)/(1 %2b \alpha)#gh-light-mode-only">
-<img src="https://render.githubusercontent.com/render/math?math=\color{white}R_{i}=PF_{i} \cdot R \cdot (\sigma^'_{i} \cdot \omega_{i} \cdot k %2b \alpha \cdot \lambda^'_{i} \cdot \sigma^'_{i} \cdot k)/(1 %2b \alpha)#gh-dark-mode-only">
+<img src="https://render.githubusercontent.com/render/math?math=R_{i}=PF_{i} \cdot R \cdot (\sigma^'_{i} \cdot \omega_{i} \cdot k %2b \alpha \cdot \lambda^'_{i} \cdot \sigma^'_{i} \cdot k)/(1 %2b \alpha)">
+
 where:
 
-<img src="https://render.githubusercontent.com/render/math?math=\sigma^'_{i} = min\{\sigma_{i}, 1/k\}#gh-light-mode-only">
-<img src="https://render.githubusercontent.com/render/math?math=\color{white}\sigma^'_{i} = min\{\sigma_{i}, 1/k\}#gh-dark-mode-only">
+<img src="https://render.githubusercontent.com/render/math?math=\sigma^'_{i} = min\{\sigma_{i}, 1/k\}">
 
 and
 
-<img src="https://render.githubusercontent.com/render/math?math=\lambda^'_{i} = min\{\lambda_{i}, 1/k\}#gh-light-mode-only">
-<img src="https://render.githubusercontent.com/render/math?math=\color{white}\lambda^'_{i} = min\{\lambda_{i}, 1/k\}#gh-dark-mode-only">
+<img src="https://render.githubusercontent.com/render/math?math=\lambda^'_{i} = min\{\lambda_{i}, 1/k\}">
 
 Operator of node `i` is credited with the following amount:
 
-<img src="https://render.githubusercontent.com/render/math?math=min\{PP_{i},R_{i})\} %2b max\{0, (PM_{i} %2b (1 - PM_{i}) \cdot \lambda_{i}/\delta_{i}) \cdot (R_{i} - PP_{i})\}#gh-light-mode-only">
-<img src="https://render.githubusercontent.com/render/math?math=\color{white}min\{PP_{i},R_{i})\} %2b max\{0, (PM_{i} %2b (1 - PM_{i}) \cdot \lambda_{i}/\delta_{i}) \cdot (R_{i} - PP_{i})\}#gh-dark-mode-only">
+<img src="https://render.githubusercontent.com/render/math?math=min\{PP_{i},R_{i})\} %2b max\{0, (PM_{i} %2b (1 - PM_{i}) \cdot \lambda_{i}/\delta_{i}) \cdot (R_{i} - PP_{i})\}">
 
 Delegate with stake `s` recieves:
 
-<img src="https://render.githubusercontent.com/render/math?math=max\{0, (1-PM_{i}) \cdot (s^'/\sigma_{i}) \cdot (R_{i} - PP_{i})\}#gh-light-mode-only">
-<img src="https://render.githubusercontent.com/render/math?math=\color{white}max\{0, (1-PM_{i}) \cdot (s^'/\sigma_{i}) \cdot (R_{i} - PP_{i})\}#gh-dark-mode-only">
+<img src="https://render.githubusercontent.com/render/math?math=max\{0, (1-PM_{i}) \cdot (s^'/\sigma_{i}) \cdot (R_{i} - PP_{i})\}">
 
 where `s'` is stake `s` scaled over total token circulating supply.
 

SECURITY.md

@@ -1,10 +0,0 @@
-Critical bug or security issue 💥
-
-If you're here because you're trying to figure out how to notify us of a security issue, go to Discord, and alert the core engineers:
-
-    Dave Hrycyszyn futurechimp#5430
-    Drazen Urch drazen#4873
-    Jedrzej Stuczynski "Jedrzej | Nym#5666"
-
-
-Please avoid opening public issues on GitHub that contain information about a potential security vulnerability as this makes it difficult to reduce the impact and harm of valid security issues.

clients/client-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "client-core"
-version = "1.0.0-rc.2"
+version = "1.0.0-rc.1"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2021"
 

clients/client-core/src/config/mod.rs

@@ -103,8 +103,15 @@ impl<T: NymConfig> Config<T> {
                 self::Client::<T>::default_reply_encryption_key_store_path(&id);
         }
 
-        if self.client.database_path.as_os_str().is_empty() {
-            self.client.database_path = self::Client::<T>::default_database_path(&id);
+        #[cfg(not(feature = "coconut"))]
+        if self
+            .client
+            .backup_bandwidth_token_keys_dir
+            .as_os_str()
+            .is_empty()
+        {
+            self.client.backup_bandwidth_token_keys_dir =
+                self::Client::<T>::default_backup_bandwidth_token_keys_dir(&id);
         }
 
         self.client.id = id;
@@ -206,8 +213,9 @@ impl<T: NymConfig> Config<T> {
         self.client.gateway_endpoint.gateway_listener.clone()
     }
 
-    pub fn get_database_path(&self) -> PathBuf {
-        self.client.database_path.clone()
+    #[cfg(not(feature = "coconut"))]
+    pub fn get_backup_bandwidth_token_keys_dir(&self) -> PathBuf {
+        self.client.backup_bandwidth_token_keys_dir.clone()
     }
 
     #[cfg(not(feature = "coconut"))]
@@ -329,8 +337,11 @@ pub struct Client<T> {
     /// Information regarding how the client should send data to gateway.
     gateway_endpoint: GatewayEndpoint,
 
-    /// Path to the database containing bandwidth credentials of this client.
-    database_path: PathBuf,
+    /// Path to directory containing public/private keys used for bandwidth token purchase.
+    /// Those are saved in case of emergency, to be able to reclaim bandwidth tokens.
+    /// The public key is the name of the file, while the private key is the content.
+    #[cfg(not(feature = "coconut"))]
+    backup_bandwidth_token_keys_dir: PathBuf,
 
     /// Ethereum private key.
     #[cfg(not(feature = "coconut"))]
@@ -364,7 +375,8 @@ impl<T: NymConfig> Default for Client<T> {
             ack_key_file: Default::default(),
             reply_encryption_key_store_path: Default::default(),
             gateway_endpoint: Default::default(),
-            database_path: Default::default(),
+            #[cfg(not(feature = "coconut"))]
+            backup_bandwidth_token_keys_dir: Default::default(),
             #[cfg(not(feature = "coconut"))]
             eth_private_key: "".to_string(),
             #[cfg(not(feature = "coconut"))]
@@ -403,8 +415,10 @@ impl<T: NymConfig> Client<T> {
     fn default_reply_encryption_key_store_path(id: &str) -> PathBuf {
         T::default_data_directory(Some(id)).join("reply_key_store")
     }
-    fn default_database_path(id: &str) -> PathBuf {
-        T::default_data_directory(Some(id)).join("db.sqlite")
+
+    #[cfg(not(feature = "coconut"))]
+    fn default_backup_bandwidth_token_keys_dir(id: &str) -> PathBuf {
+        T::default_data_directory(Some(id)).join("backup_bandwidth_token_keys")
     }
 }
 

clients/credential/Cargo.toml

@@ -20,7 +20,6 @@ tokio = { version = "1.4", features = ["rt-multi-thread", "net", "signal", "macr
 coconut-bandwidth-contract-common = { path = "../../common/cosmwasm-smart-contracts/coconut-bandwidth-contract" }
 coconut-interface = { path = "../../common/coconut-interface" }
 credentials = { path = "../../common/credentials" }
-credential-storage = { path = "../../common/credential-storage" }
 crypto = { path = "../../common/crypto", features = ["rand", "asymmetric", "symmetric", "aes", "hashing"] }
 network-defaults = { path = "../../common/network-defaults" }
 pemstore = { path = "../../common/pemstore" }

clients/credential/src/commands.rs

@@ -9,8 +9,6 @@ use std::str::FromStr;
 use url::Url;
 
 use coconut_interface::{Attribute, Base58, BlindSignRequest, Bytable, Parameters};
-use credential_storage::storage::Storage;
-use credential_storage::PersistentStorage;
 use credentials::coconut::bandwidth::{BandwidthVoucher, TOTAL_ATTRIBUTES};
 use credentials::coconut::utils::obtain_aggregate_signature;
 use crypto::asymmetric::{encryption, identity};
@@ -34,7 +32,7 @@ pub(crate) enum Commands {
 
 #[async_trait]
 pub(crate) trait Execute {
-    async fn execute(&self, db: &mut PickleDb, shared_storage: PersistentStorage) -> Result<()>;
+    async fn execute(&self, db: &mut PickleDb) -> Result<()>;
 }
 
 #[derive(Args, Clone)]
@@ -46,7 +44,7 @@ pub(crate) struct Deposit {
 
 #[async_trait]
 impl Execute for Deposit {
-    async fn execute(&self, db: &mut PickleDb, _shared_storage: PersistentStorage) -> Result<()> {
+    async fn execute(&self, db: &mut PickleDb) -> Result<()> {
         let mut rng = OsRng;
         let signing_keypair = KeyPair::from(identity::KeyPair::new(&mut rng));
         let encryption_keypair = KeyPair::from(encryption::KeyPair::new(&mut rng));
@@ -82,7 +80,7 @@ pub(crate) struct ListDeposits {}
 
 #[async_trait]
 impl Execute for ListDeposits {
-    async fn execute(&self, db: &mut PickleDb, _shared_storage: PersistentStorage) -> Result<()> {
+    async fn execute(&self, db: &mut PickleDb) -> Result<()> {
         for kv in db.iter() {
             println!("{:?}", kv.get_value::<State>());
         }
@@ -104,7 +102,7 @@ pub(crate) struct GetCredential {
 
 #[async_trait]
 impl Execute for GetCredential {
-    async fn execute(&self, db: &mut PickleDb, shared_storage: PersistentStorage) -> Result<()> {
+    async fn execute(&self, db: &mut PickleDb) -> Result<()> {
         let mut state = db
             .get::<State>(&self.tx_hash)
             .ok_or(CredentialClientError::NoDeposit)?;
@@ -164,15 +162,6 @@ impl Execute for GetCredential {
 
         let signature =
             obtain_aggregate_signature(&params, &bandwidth_credential_attributes, &urls).await?;
-        shared_storage
-            .insert_coconut_credential(
-                state.amount.to_string(),
-                VOUCHER_INFO.to_string(),
-                bandwidth_credential_attributes.get_private_attributes()[0].to_bs58(),
-                bandwidth_credential_attributes.get_private_attributes()[1].to_bs58(),
-                signature.to_bs58(),
-            )
-            .await?;
         state.signature = Some(signature.to_bs58());
         db.set(&self.tx_hash, &state).unwrap();
 
@@ -181,3 +170,17 @@ impl Execute for GetCredential {
         Ok(())
     }
 }
+
+#[derive(Args, Clone)]
+pub(crate) struct SpendCredential {
+    /// Spend one of the acquired credentials
+    #[clap(long)]
+    id: usize,
+}
+
+#[async_trait]
+impl Execute for SpendCredential {
+    async fn execute(&self, _db: &mut PickleDb) -> Result<()> {
+        Ok(())
+    }
+}

clients/credential/src/error.rs

@@ -3,7 +3,6 @@
 
 use thiserror::Error;
 
-use credential_storage::error::StorageError;
 use credentials::error::Error as CredentialError;
 use crypto::asymmetric::encryption::KeyRecoveryError;
 use crypto::asymmetric::identity::Ed25519RecoveryError;
@@ -39,7 +38,4 @@ pub enum CredentialClientError {
 
     #[error("Could not parse X25519 data")]
     X25519ParseError(#[from] KeyRecoveryError),
-
-    #[error("Could not use shared storage")]
-    SharedStorageError(#[from] StorageError),
 }

clients/credential/src/main.rs

@@ -15,9 +15,9 @@ cfg_if::cfg_if! {
         use clap::Parser;
         use pickledb::{PickleDb, PickleDbDumpPolicy, SerializationMethod};
 
-        pub const MNEMONIC: &str = "jazz fatigue diagram account outer wrist slide cherry mother grid network pause wolf pig round answer mail junior better hair dismiss toward access end";
+        pub const MNEMONIC: &str = "sun surge soon stomach flavor country gorilla dress oblige stamp attract hip soldier agree steel prize nuclear know enjoy arm bargain always theme matter";
         pub const NYMD_URL: &str = "http://127.0.0.1:26657";
-        pub const CONTRACT_ADDRESS: &str = "nymt1nc5tatafv6eyq7llkr2gv50ff9e22mnfp9pc5s";
+        pub const CONTRACT_ADDRESS: &str = "nymt1vhjnzk9ly03dugffvzfcwgry4dgc8x0sscmfl2";
         pub const SIGNER_AUTHORITIES: [&str; 1] = [
             "http://127.0.0.1:8080",
         ];
@@ -32,8 +32,6 @@ cfg_if::cfg_if! {
         #[tokio::main]
         async fn main() -> Result<()> {
             let args = Cli::parse();
-
-            let shared_storage = credential_storage::initialise_storage(std::path::PathBuf::from("/tmp/credential.db")).await;
             let mut db = match PickleDb::load(
                 "credential.db",
                 PickleDbDumpPolicy::AutoDump,
@@ -48,9 +46,9 @@ cfg_if::cfg_if! {
             };
 
             match &args.command {
-                Commands::Deposit(m) => m.execute(&mut db, shared_storage).await?,
-                Commands::ListDeposits(m) => m.execute(&mut db, shared_storage).await?,
-                Commands::GetCredential(m) => m.execute(&mut db, shared_storage).await?,
+                Commands::Deposit(m) => m.execute(&mut db).await?,
+                Commands::ListDeposits(m) => m.execute(&mut db).await?,
+                Commands::GetCredential(m) => m.execute(&mut db).await?,
             }
 
             Ok(())

clients/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.0.0-rc.2"
+version = "1.0.0-rc.1"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 edition = "2021"
 rust-version = "1.56"
@@ -34,7 +34,6 @@ tokio-tungstenite = "0.14" # websocket
 client-core = { path = "../client-core" }
 coconut-interface = { path = "../../common/coconut-interface", optional = true }
 credentials = { path = "../../common/credentials", optional = true }
-credential-storage = { path = "../../common/credential-storage" }
 config = { path = "../../common/config" }
 crypto = { path = "../../common/crypto" }
 gateway-client = { path = "../../common/client-libs/gateway-client" }
@@ -43,12 +42,12 @@ nymsphinx = { path = "../../common/nymsphinx" }
 pemstore = { path = "../../common/pemstore" }
 topology = { path = "../../common/topology" }
 websocket-requests = { path = "websocket-requests" }
-validator-client = { path = "../../common/client-libs/validator-client", features = ["nymd-client"] }
+validator-client = { path = "../../common/client-libs/validator-client" }
 version-checker = { path = "../../common/version-checker" }
 network-defaults = { path = "../../common/network-defaults" }
 
 [features]
-coconut = ["coconut-interface", "credentials", "credentials/coconut", "gateway-requests/coconut", "gateway-client/coconut", "client-core/coconut"]
+coconut = ["coconut-interface", "credentials", "credentials/coconut", "gateway-requests/coconut", "gateway-client/coconut"]
 eth = []
 
 [dev-dependencies]

clients/native/src/client/config/template.rs

@@ -46,8 +46,10 @@ public_encryption_key_file = '{{ client.public_encryption_key_file }}'
 # sent but not received back.
 reply_encryption_key_store_path = '{{ client.reply_encryption_key_store_path }}'
 
-# Path to the database containing bandwidth credentials
-database_path = '{{ client.database_path }}'
+# Path to directory containing public/private keys used for bandwidth token purchase.
+# Those are saved in case of emergency, to be able to reclaim bandwidth tokens.
+# The public key is the name of the file, while the private key is the content.
+backup_bandwidth_token_keys_dir = '{{ client.backup_bandwidth_token_keys_dir }}'
 
 # Ethereum private key.
 eth_private_key = '{{ client.eth_private_key }}'

clients/native/src/client/mod.rs

@@ -174,16 +174,14 @@ impl NymClient {
 
         #[cfg(feature = "coconut")]
         let bandwidth_controller = BandwidthController::new(
-            credential_storage::initialise_storage(self.config.get_base().get_database_path())
-                .await,
             self.config.get_base().get_validator_api_endpoints(),
+            *self.key_manager.identity_keypair().public_key(),
         );
         #[cfg(not(feature = "coconut"))]
         let bandwidth_controller = BandwidthController::new(
-            credential_storage::initialise_storage(self.config.get_base().get_database_path())
-                .await,
             self.config.get_base().get_eth_endpoint(),
             self.config.get_base().get_eth_private_key(),
+            self.config.get_base().get_backup_bandwidth_token_keys_dir(),
         )
         .expect("Could not create bandwidth controller");
 

clients/native/src/commands/init.rs

@@ -4,10 +4,21 @@
 use clap::{App, Arg, ArgMatches};
 use client_core::client::key_manager::KeyManager;
 use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
+#[cfg(feature = "coconut")]
+use coconut_interface::{Credential, Parameters};
 use config::NymConfig;
+#[cfg(feature = "coconut")]
+use credentials::coconut::{
+    bandwidth::prepare_for_spending, bandwidth::BandwidthVoucher, bandwidth::TOTAL_ATTRIBUTES,
+    utils::obtain_aggregate_signature,
+};
+#[cfg(feature = "coconut")]
+use credentials::obtain_aggregate_verification_key;
 use crypto::asymmetric::{encryption, identity};
 use gateway_client::GatewayClient;
 use gateway_requests::registration::handshake::SharedKeys;
+#[cfg(feature = "coconut")]
+use network_defaults::{BANDWIDTH_VALUE, VOUCHER_INFO};
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
 use rand::rngs::OsRng;
@@ -18,6 +29,8 @@ use std::sync::Arc;
 use std::time::Duration;
 use topology::{filter::VersionFilterable, gateway};
 use url::Url;
+#[cfg(feature = "coconut")]
+use validator_client::nymd::tx::Hash;
 
 use crate::client::config::Config;
 use crate::commands::override_config;
@@ -88,6 +101,46 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
     app
 }
 
+// this behaviour should definitely be changed, we shouldn't
+// need to get bandwidth credential for registration
+#[cfg(feature = "coconut")]
+async fn _prepare_temporary_credential(validators: &[Url], raw_identity: &[u8]) -> Credential {
+    let verification_key = obtain_aggregate_verification_key(validators)
+        .await
+        .expect("could not obtain aggregate verification key of validators");
+
+    let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
+    let mut rng = OsRng;
+    let bandwidth_credential_attributes = BandwidthVoucher::new(
+        &params,
+        BANDWIDTH_VALUE.to_string(),
+        VOUCHER_INFO.to_string(),
+        Hash::new([0; 32]),
+        // workaround for putting a valid value here, without deriving clone for the private
+        // key, until we have actual useful values
+        identity::PrivateKey::from_base58_string(
+            identity::KeyPair::new(&mut rng)
+                .private_key()
+                .to_base58_string(),
+        )
+        .unwrap(),
+        encryption::KeyPair::new(&mut rng).private_key().clone(),
+    );
+
+    let bandwidth_credential =
+        obtain_aggregate_signature(&params, &bandwidth_credential_attributes, validators)
+            .await
+            .expect("could not obtain bandwidth credential");
+
+    prepare_for_spending(
+        raw_identity,
+        &bandwidth_credential,
+        &bandwidth_credential_attributes,
+        &verification_key,
+    )
+    .expect("could not prepare out bandwidth credential for spending")
+}
+
 async fn register_with_gateway(
     gateway: &gateway::Node,
     our_identity: Arc<identity::KeyPair>,

clients/socks5/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.0.0-rc.2"
+version = "1.0.0-rc.1"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2021"
 rust-version = "1.56"
@@ -27,7 +27,6 @@ url = "2.2"
 client-core = { path = "../client-core" }
 coconut-interface = { path = "../../common/coconut-interface", optional = true }
 credentials = { path = "../../common/credentials", optional = true }
-credential-storage = { path = "../../common/credential-storage" }
 config = { path = "../../common/config" }
 crypto = { path = "../../common/crypto" }
 gateway-client = { path = "../../common/client-libs/gateway-client" }
@@ -38,12 +37,12 @@ socks5-requests = { path = "../../common/socks5/requests" }
 topology = { path = "../../common/topology" }
 pemstore = { path = "../../common/pemstore" }
 proxy-helpers = { path = "../../common/socks5/proxy-helpers" }
-validator-client = { path = "../../common/client-libs/validator-client", features = ["nymd-client"] }
+validator-client = { path = "../../common/client-libs/validator-client" }
 version-checker = { path = "../../common/version-checker" }
 network-defaults = { path = "../../common/network-defaults" }
 
 [features]
-coconut = ["coconut-interface", "credentials", "gateway-requests/coconut", "gateway-client/coconut", "credentials/coconut", "client-core/coconut"]
+coconut = ["coconut-interface", "credentials", "gateway-requests/coconut", "gateway-client/coconut", "credentials/coconut"]
 eth = []
 
 [build-dependencies]

clients/socks5/src/client/config/template.rs

@@ -46,8 +46,10 @@ public_encryption_key_file = '{{ client.public_encryption_key_file }}'
 # sent but not received back.
 reply_encryption_key_store_path = '{{ client.reply_encryption_key_store_path }}'
 
-# Path to the database containing bandwidth credentials
-database_path = '{{ client.database_path }}'
+# Path to directory containing public/private keys used for bandwidth token purchase.
+# Those are saved in case of emergency, to be able to reclaim bandwidth tokens.
+# The public key is the name of the file, while the private key is the content.
+backup_bandwidth_token_keys_dir = '{{ client.backup_bandwidth_token_keys_dir }}'
 
 # Ethereum private key.
 eth_private_key = '{{ client.eth_private_key }}'

clients/socks5/src/client/mod.rs

@@ -162,16 +162,14 @@ impl NymClient {
 
         #[cfg(feature = "coconut")]
         let bandwidth_controller = BandwidthController::new(
-            credential_storage::initialise_storage(self.config.get_base().get_database_path())
-                .await,
             self.config.get_base().get_validator_api_endpoints(),
+            *self.key_manager.identity_keypair().public_key(),
         );
         #[cfg(not(feature = "coconut"))]
         let bandwidth_controller = BandwidthController::new(
-            credential_storage::initialise_storage(self.config.get_base().get_database_path())
-                .await,
             self.config.get_base().get_eth_endpoint(),
             self.config.get_base().get_eth_private_key(),
+            self.config.get_base().get_backup_bandwidth_token_keys_dir(),
         )
         .expect("Could not create bandwidth controller");
 

clients/socks5/src/commands/init.rs

@@ -4,10 +4,21 @@
 use clap::{App, Arg, ArgMatches};
 use client_core::client::key_manager::KeyManager;
 use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
+#[cfg(feature = "coconut")]
+use coconut_interface::{Credential, Parameters};
 use config::NymConfig;
+#[cfg(feature = "coconut")]
+use credentials::coconut::{
+    bandwidth::prepare_for_spending, bandwidth::BandwidthVoucher, bandwidth::TOTAL_ATTRIBUTES,
+    utils::obtain_aggregate_signature,
+};
+#[cfg(feature = "coconut")]
+use credentials::obtain_aggregate_verification_key;
 use crypto::asymmetric::{encryption, identity};
 use gateway_client::GatewayClient;
 use gateway_requests::registration::handshake::SharedKeys;
+#[cfg(feature = "coconut")]
+use network_defaults::BANDWIDTH_VALUE;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
 use rand::{prelude::SliceRandom, rngs::OsRng, thread_rng};
@@ -16,6 +27,8 @@ use std::sync::Arc;
 use std::time::Duration;
 use topology::{filter::VersionFilterable, gateway};
 use url::Url;
+#[cfg(feature = "coconut")]
+use validator_client::nymd::tx::Hash;
 
 use crate::client::config::Config;
 use crate::commands::override_config;
@@ -88,6 +101,46 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
     app
 }
 
+// this behaviour should definitely be changed, we shouldn't
+// need to get bandwidth credential for registration
+#[cfg(feature = "coconut")]
+async fn _prepare_temporary_credential(validators: &[Url], raw_identity: &[u8]) -> Credential {
+    let verification_key = obtain_aggregate_verification_key(validators)
+        .await
+        .expect("could not obtain aggregate verification key of validators");
+
+    let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
+    let mut rng = OsRng;
+    let bandwidth_credential_attributes = BandwidthVoucher::new(
+        &params,
+        BANDWIDTH_VALUE.to_string(),
+        network_defaults::VOUCHER_INFO.to_string(),
+        Hash::new([0; 32]),
+        // workaround for putting a valid value here, without deriving clone for the private
+        // key, until we have actual useful values
+        identity::PrivateKey::from_base58_string(
+            identity::KeyPair::new(&mut rng)
+                .private_key()
+                .to_base58_string(),
+        )
+        .unwrap(),
+        encryption::KeyPair::new(&mut rng).private_key().clone(),
+    );
+
+    let bandwidth_credential =
+        obtain_aggregate_signature(&params, &bandwidth_credential_attributes, validators)
+            .await
+            .expect("could not obtain bandwidth credential");
+
+    prepare_for_spending(
+        raw_identity,
+        &bandwidth_credential,
+        &bandwidth_credential_attributes,
+        &verification_key,
+    )
+    .expect("could not prepare out bandwidth credential for spending")
+}
+
 async fn register_with_gateway(
     gateway: &gateway::Node,
     our_identity: Arc<identity::KeyPair>,

clients/webassembly/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "nym-client-wasm"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jedrzej Stuczynski <andrew@nymtech.net>"]
-version = "1.0.0-rc.2"
+version = "1.0.0-rc.1"
 edition = "2021"
 keywords = ["nym", "sphinx", "wasm", "webassembly", "privacy", "client"]
 license = "Apache-2.0"

clients/webassembly/src/client/mod.rs

@@ -109,6 +109,12 @@ impl NymClient {
     pub async fn initial_setup(self) -> Self {
         let testnet_mode = self.testnet_mode;
 
+        #[cfg(feature = "coconut")]
+        let bandwidth_controller = Some(gateway_client::bandwidth::BandwidthController::new(
+            vec![self.validator_server.clone()],
+            *self.identity.public_key(),
+        ));
+        #[cfg(not(feature = "coconut"))]
         let bandwidth_controller = None;
 
         let mut client = self.get_and_update_topology().await;

common/client-libs/gateway-client/Cargo.toml

@@ -17,9 +17,9 @@ url = "2.2"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 secp256k1 = "0.20.3"
 web3 = { version = "0.17.0", default-features = false }
-async-trait = { version = "0.1.51" }
 
 # internal
+cosmrs = { version = "0.4.1", optional = true }
 credentials = { path = "../../credentials" }
 crypto = { path = "../../crypto" }
 gateway-requests = { path = "../../../gateway/gateway-requests" }
@@ -41,9 +41,6 @@ features = ["macros", "rt", "net", "sync", "time"]
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-tungstenite]
 version = "0.14"
 
-[target."cfg(not(target_arch = \"wasm32\"))".dependencies.credential-storage]
-path = "../../credential-storage"
-
 # wasm-only dependencies
 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-bindgen]
 version = "0.2"
@@ -72,6 +69,6 @@ features = ["js"]
 #url = "2.1"
 
 [features]
-coconut = ["gateway-requests/coconut", "coconut-interface", "validator-client", "credentials/coconut"]
+coconut = ["gateway-requests/coconut", "coconut-interface", "validator-client", "credentials/coconut", "cosmrs"]
 wasm = ["web3/wasm", "web3/http", "web3/signing"]
 default = ["web3/default"]

common/client-libs/gateway-client/src/bandwidth.rs

@@ -1,35 +1,33 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-#[cfg(target_arch = "wasm32")]
-use crate::wasm_storage::{Storage, StorageError};
 #[cfg(feature = "coconut")]
-use coconut_interface::Base58;
-#[cfg(feature = "coconut")]
-#[cfg(not(target_arch = "wasm32"))]
-use credential_storage::error::StorageError;
-#[cfg(not(target_arch = "wasm32"))]
-use credential_storage::storage::Storage;
+use cosmrs::tx::Hash;
 #[cfg(feature = "coconut")]
 use credentials::coconut::{
-    bandwidth::prepare_for_spending, utils::obtain_aggregate_verification_key,
+    bandwidth::{prepare_for_spending, BandwidthVoucher, TOTAL_ATTRIBUTES},
+    utils::{obtain_aggregate_signature, obtain_aggregate_verification_key},
 };
 #[cfg(not(feature = "coconut"))]
 use credentials::token::bandwidth::TokenCredential;
-#[cfg(not(feature = "coconut"))]
+#[cfg(feature = "coconut")]
+use crypto::asymmetric::encryption;
 use crypto::asymmetric::identity;
+use network_defaults::BANDWIDTH_VALUE;
 #[cfg(not(feature = "coconut"))]
 use network_defaults::{
-    eth_contract::ETH_ERC20_JSON_ABI, eth_contract::ETH_JSON_ABI, BANDWIDTH_VALUE,
-    ETH_BURN_FUNCTION_NAME, ETH_CONTRACT_ADDRESS, ETH_ERC20_APPROVE_FUNCTION_NAME,
-    ETH_ERC20_CONTRACT_ADDRESS, ETH_MIN_BLOCK_DEPTH, TOKENS_TO_BURN, UTOKENS_TO_BURN,
+    eth_contract::ETH_ERC20_JSON_ABI, eth_contract::ETH_JSON_ABI, ETH_BURN_FUNCTION_NAME,
+    ETH_CONTRACT_ADDRESS, ETH_ERC20_APPROVE_FUNCTION_NAME, ETH_ERC20_CONTRACT_ADDRESS,
+    ETH_MIN_BLOCK_DEPTH, TOKENS_TO_BURN, UTOKENS_TO_BURN,
 };
 #[cfg(not(feature = "coconut"))]
 use pemstore::traits::PemStorableKeyPair;
-#[cfg(not(feature = "coconut"))]
 use rand::rngs::OsRng;
 #[cfg(not(feature = "coconut"))]
 use secp256k1::SecretKey;
+#[cfg(not(feature = "coconut"))]
+use std::io::{Read, Write};
+#[cfg(not(feature = "coconut"))]
 use std::str::FromStr;
 #[cfg(not(feature = "coconut"))]
 use web3::{
@@ -70,35 +68,35 @@ pub fn eth_erc20_contract(web3: Web3<Http>) -> Contract<Http> {
 }
 
 #[derive(Clone)]
-pub struct BandwidthController<St: Storage> {
-    storage: St,
+pub struct BandwidthController {
     #[cfg(feature = "coconut")]
     validator_endpoints: Vec<url::Url>,
+    #[cfg(feature = "coconut")]
+    identity: identity::PublicKey,
     #[cfg(not(feature = "coconut"))]
     contract: Contract<Http>,
     #[cfg(not(feature = "coconut"))]
     erc20_contract: Contract<Http>,
     #[cfg(not(feature = "coconut"))]
     eth_private_key: SecretKey,
+    #[cfg(not(feature = "coconut"))]
+    backup_bandwidth_token_keys_dir: std::path::PathBuf,
 }
 
-impl<St> BandwidthController<St>
-where
-    St: Storage + Clone + 'static,
-{
+impl BandwidthController {
     #[cfg(feature = "coconut")]
-    pub fn new(storage: St, validator_endpoints: Vec<url::Url>) -> Self {
+    pub fn new(validator_endpoints: Vec<url::Url>, identity: identity::PublicKey) -> Self {
         BandwidthController {
-            storage,
             validator_endpoints,
+            identity,
         }
     }
 
     #[cfg(not(feature = "coconut"))]
     pub fn new(
-        storage: St,
         eth_endpoint: String,
         eth_private_key: String,
+        backup_bandwidth_token_keys_dir: std::path::PathBuf,
     ) -> Result<Self, GatewayClientError> {
         // Fail early, on invalid url
         let transport =
@@ -111,42 +109,60 @@ where
             .map_err(|_| GatewayClientError::InvalidEthereumPrivateKey)?;
 
         Ok(BandwidthController {
-            storage,
             contract,
             erc20_contract,
             eth_private_key,
+            backup_bandwidth_token_keys_dir,
         })
     }
 
     #[cfg(not(feature = "coconut"))]
-    async fn backup_keypair(&self, keypair: &identity::KeyPair) -> Result<(), GatewayClientError> {
-        self.storage
-            .insert_erc20_credential(
-                keypair.public_key().to_base58_string(),
-                keypair.private_key().to_base58_string(),
-            )
-            .await?;
+    fn backup_keypair(&self, keypair: &identity::KeyPair) -> Result<(), GatewayClientError> {
+        std::fs::create_dir_all(&self.backup_bandwidth_token_keys_dir)?;
+        let file_path = self
+            .backup_bandwidth_token_keys_dir
+            .join(keypair.public_key().to_base58_string());
+        let mut file = std::fs::File::create(file_path)?;
+        file.write_all(&keypair.private_key().to_bytes())?;
 
         Ok(())
     }
 
     #[cfg(not(feature = "coconut"))]
-    async fn restore_keypair(&self) -> Result<identity::KeyPair, GatewayClientError> {
-        let data = self.storage.get_next_erc20_credential().await?;
-        let public_key = identity::PublicKey::from_base58_string(data.public_key).unwrap();
-        let private_key = identity::PrivateKey::from_base58_string(data.private_key).unwrap();
-
-        Ok(identity::KeyPair::from_keys(private_key, public_key))
+    fn restore_keypair(&self) -> Result<identity::KeyPair, GatewayClientError> {
+        std::fs::create_dir_all(&self.backup_bandwidth_token_keys_dir)?;
+        let file = std::fs::read_dir(&self.backup_bandwidth_token_keys_dir)?
+            .find(|entry| {
+                entry
+                    .as_ref()
+                    .map(|entry| entry.path().is_file())
+                    .unwrap_or(false)
+            })
+            .unwrap_or_else(|| Err(std::io::Error::from(std::io::ErrorKind::NotFound)))?;
+        let file_path = file.path();
+        let pub_key = file_path
+            .file_name()
+            .ok_or_else(|| std::io::Error::from(std::io::ErrorKind::NotFound))?
+            .to_str()
+            .ok_or_else(|| std::io::Error::from(std::io::ErrorKind::NotFound))?;
+        let mut priv_key = vec![];
+        std::fs::File::open(file_path.clone())?.read_to_end(&mut priv_key)?;
+        Ok(identity::KeyPair::from_keys(
+            identity::PrivateKey::from_bytes(&priv_key).unwrap(),
+            identity::PublicKey::from_base58_string(pub_key).unwrap(),
+        ))
     }
 
     #[cfg(not(feature = "coconut"))]
-    async fn mark_keypair_as_spent(
-        &self,
-        keypair: &identity::KeyPair,
-    ) -> Result<(), GatewayClientError> {
-        self.storage
-            .consume_erc20_credential(keypair.public_key().to_base58_string())
-            .await?;
+    fn mark_keypair_as_spent(&self, keypair: &identity::KeyPair) -> Result<(), GatewayClientError> {
+        let mut spent_dir = self.backup_bandwidth_token_keys_dir.clone();
+        spent_dir.push("spent");
+        std::fs::create_dir_all(&spent_dir)?;
+        let file_path_old = self
+            .backup_bandwidth_token_keys_dir
+            .join(keypair.public_key().to_base58_string());
+        let file_path_new = spent_dir.join(keypair.public_key().to_base58_string());
+        std::fs::rename(file_path_old, file_path_new)?;
 
         Ok(())
     }
@@ -156,24 +172,39 @@ where
         &self,
     ) -> Result<coconut_interface::Credential, GatewayClientError> {
         let verification_key = obtain_aggregate_verification_key(&self.validator_endpoints).await?;
-        let bandwidth_credential = self.storage.get_next_coconut_credential().await?;
-        let voucher_value = u64::from_str(&bandwidth_credential.voucher_value)
-            .map_err(|_| StorageError::InconsistentData)?;
-        let voucher_info = bandwidth_credential.voucher_info.clone();
-        let serial_number =
-            coconut_interface::Attribute::try_from_bs58(bandwidth_credential.serial_number)?;
-        let binding_number =
-            coconut_interface::Attribute::try_from_bs58(bandwidth_credential.binding_number)?;
-        let signature =
-            coconut_interface::Signature::try_from_bs58(bandwidth_credential.signature)?;
+        let params = coconut_interface::Parameters::new(TOTAL_ATTRIBUTES).unwrap();
+
+        let mut rng = OsRng;
+        // TODO: Decide what is the value and additional info associated with the bandwidth voucher
+        let bandwidth_credential_attributes = BandwidthVoucher::new(
+            &params,
+            BANDWIDTH_VALUE.to_string(),
+            network_defaults::VOUCHER_INFO.to_string(),
+            Hash::new([0; 32]),
+            // workaround for putting a valid value here, without deriving clone for the private
+            // key, until we have actual useful values
+            identity::PrivateKey::from_base58_string(
+                identity::KeyPair::new(&mut rng)
+                    .private_key()
+                    .to_base58_string(),
+            )
+            .unwrap(),
+            encryption::KeyPair::new(&mut rng).private_key().clone(),
+        );
+
+        let bandwidth_credential = obtain_aggregate_signature(
+            &params,
+            &bandwidth_credential_attributes,
+            &self.validator_endpoints,
+        )
+        .await?;
+        // the above would presumably be loaded from a file
 
         // the below would only be executed once we know where we want to spend it (i.e. which gateway and stuff)
         Ok(prepare_for_spending(
-            voucher_value,
-            voucher_info,
-            serial_number,
-            binding_number,
-            &signature,
+            &self.identity.to_bytes(),
+            &bandwidth_credential,
+            &bandwidth_credential_attributes,
             &verification_key,
         )?)
     }
@@ -184,12 +215,12 @@ where
         gateway_identity: identity::PublicKey,
         gateway_owner: String,
     ) -> Result<TokenCredential, GatewayClientError> {
-        let kp = match self.restore_keypair().await {
+        let kp = match self.restore_keypair() {
             Ok(kp) => kp,
             Err(_) => {
                 let mut rng = OsRng;
                 let kp = identity::KeyPair::new(&mut rng);
-                self.backup_keypair(&kp).await?;
+                self.backup_keypair(&kp)?;
                 kp
             }
         };
@@ -199,7 +230,7 @@ where
         self.buy_token_credential(verification_key, signed_verification_key, gateway_owner)
             .await?;
 
-        self.mark_keypair_as_spent(&kp).await?;
+        self.mark_keypair_as_spent(&kp)?;
 
         let message: Vec<u8> = verification_key
             .to_bytes()

common/client-libs/gateway-client/src/client.rs

@@ -9,12 +9,8 @@ pub use crate::packet_router::{
     AcknowledgementReceiver, AcknowledgementSender, MixnetMessageReceiver, MixnetMessageSender,
 };
 use crate::socket_state::{PartiallyDelegated, SocketState};
-#[cfg(target_arch = "wasm32")]
-use crate::wasm_storage::PersistentStorage;
 #[cfg(feature = "coconut")]
 use coconut_interface::Credential;
-#[cfg(not(target_arch = "wasm32"))]
-use credential_storage::PersistentStorage;
 #[cfg(not(feature = "coconut"))]
 use credentials::token::bandwidth::TokenCredential;
 use crypto::asymmetric::identity;
@@ -55,7 +51,7 @@ pub struct GatewayClient {
     connection: SocketState,
     packet_router: PacketRouter,
     response_timeout_duration: Duration,
-    bandwidth_controller: Option<BandwidthController<PersistentStorage>>,
+    bandwidth_controller: Option<BandwidthController>,
 
     // reconnection related variables
     /// Specifies whether client should try to reconnect to gateway on connection failure.
@@ -79,7 +75,7 @@ impl GatewayClient {
         mixnet_message_sender: MixnetMessageSender,
         ack_sender: AcknowledgementSender,
         response_timeout_duration: Duration,
-        bandwidth_controller: Option<BandwidthController<PersistentStorage>>,
+        bandwidth_controller: Option<BandwidthController>,
     ) -> Self {
         GatewayClient {
             authenticated: false,

common/client-libs/gateway-client/src/error.rs

@@ -1,10 +1,6 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-#[cfg(target_arch = "wasm32")]
-use crate::wasm_storage::StorageError;
-#[cfg(not(target_arch = "wasm32"))]
-use credential_storage::error::StorageError;
 use gateway_requests::registration::handshake::error::HandshakeError;
 use std::io;
 use thiserror::Error;
@@ -25,18 +21,15 @@ pub enum GatewayClientError {
     #[error("There was a network error - {0}")]
     NetworkError(#[from] WsError),
 
-    #[error("There was a credential storage error - {0}")]
-    CredentialStorageError(#[from] StorageError),
-
-    #[cfg(feature = "coconut")]
-    #[error("Coconut error - {0}")]
-    CoconutError(#[from] coconut_interface::CoconutError),
-
     // TODO: see if `JsValue` is a reasonable type for this
     #[cfg(target_arch = "wasm32")]
     #[error("There was a network error")]
     NetworkErrorWasm(JsValue),
 
+    #[cfg(not(feature = "coconut"))]
+    #[error("Keypair IO error - {0}")]
+    IOError(#[from] std::io::Error),
+
     #[cfg(not(feature = "coconut"))]
     #[error("Could not burn ERC20 token in Ethereum smart contract - {0}")]
     BurnTokenError(#[from] Web3Error),
@@ -76,9 +69,6 @@ pub enum GatewayClientError {
     #[error("Client does not have enough bandwidth: estimated {0}, remaining: {1}")]
     NotEnoughBandwidth(i64, i64),
 
-    #[error("There are no more bandwidth credentials acquired. Please buy some more if you want to use the mixnet")]
-    NoMoreBandwidthCredentials,
-
     #[error("Received an unexpected response")]
     UnexpectedResponse,
 

common/client-libs/gateway-client/src/lib.rs

@@ -13,8 +13,6 @@ pub mod client;
 pub mod error;
 pub mod packet_router;
 pub mod socket_state;
-#[cfg(feature = "wasm")]
-mod wasm_storage;
 
 /// Helper method for reading from websocket stream. Helps to flatten the structure.
 pub(crate) fn cleanup_socket_message(

common/client-libs/gateway-client/src/wasm_storage.rs

@@ -1,98 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use async_trait::async_trait;
-use thiserror::Error;
-
-#[derive(Error, Debug)]
-pub enum StorageError {
-    #[error("Wasm client is not yet supported")]
-    WasmNotSupported,
-
-    #[allow(dead_code)]
-    #[error("Code shouldn't reach this point")]
-    InconsistentData,
-}
-
-#[derive(Clone)]
-pub struct PersistentStorage {}
-
-pub struct CoconutCredential {
-    pub id: i64,
-    pub voucher_value: String,
-    pub voucher_info: String,
-    pub serial_number: String,
-    pub binding_number: String,
-    pub signature: String,
-}
-
-pub struct ERC20Credential {
-    pub id: i64,
-    pub public_key: String,
-    pub private_key: String,
-    pub consumed: bool,
-}
-
-#[async_trait]
-pub trait Storage: Send + Sync {
-    async fn insert_coconut_credential(
-        &self,
-        voucher_value: String,
-        voucher_info: String,
-        serial_number: String,
-        binding_number: String,
-        signature: String,
-    ) -> Result<(), StorageError>;
-
-    async fn get_next_coconut_credential(&self) -> Result<CoconutCredential, StorageError>;
-
-    async fn remove_coconut_credential(&self, id: i64) -> Result<(), StorageError>;
-
-    async fn insert_erc20_credential(
-        &self,
-        public_key: String,
-        private_key: String,
-    ) -> Result<(), StorageError>;
-
-    async fn get_next_erc20_credential(&self) -> Result<ERC20Credential, StorageError>;
-
-    async fn consume_erc20_credential(&self, public_key: String) -> Result<(), StorageError>;
-}
-
-#[async_trait]
-impl Storage for PersistentStorage {
-    async fn insert_coconut_credential(
-        &self,
-        _voucher_value: String,
-        _voucher_info: String,
-        _serial_number: String,
-        _binding_number: String,
-        _signature: String,
-    ) -> Result<(), StorageError> {
-        Err(StorageError::WasmNotSupported)
-    }
-
-    async fn get_next_coconut_credential(&self) -> Result<CoconutCredential, StorageError> {
-        Err(StorageError::WasmNotSupported)
-    }
-
-    async fn remove_coconut_credential(&self, _id: i64) -> Result<(), StorageError> {
-        Err(StorageError::WasmNotSupported)
-    }
-
-    async fn insert_erc20_credential(
-        &self,
-        _public_key: String,
-        _private_key: String,
-    ) -> Result<(), StorageError> {
-        Err(StorageError::WasmNotSupported)
-    }
-
-    async fn get_next_erc20_credential(&self) -> Result<ERC20Credential, StorageError> {
-        Err(StorageError::WasmNotSupported)
-    }
-
-    async fn consume_erc20_credential(&self, _public_key: String) -> Result<(), StorageError> {
-        Err(StorageError::WasmNotSupported)
-    }
-}

common/client-libs/validator-client/Cargo.toml

@@ -37,7 +37,7 @@ prost = { version = "0.9", default-features = false, optional = true }
 flate2 = { version = "1.0.20", optional = true }
 sha2 = { version = "0.9.5", optional = true }
 itertools = { version = "0.10", optional = true }
-cosmwasm-std = { version = "1.0.0-beta8", optional = true }
+cosmwasm-std = { version = "1.0.0-beta6", optional = true }
 
 [dev-dependencies]
 ts-rs = "6.1.2"

common/client-libs/validator-client/src/client.rs

@@ -153,10 +153,6 @@ impl Client<SigningNymdClient> {
         )?;
         Ok(())
     }
-
-    pub fn set_nymd_simulated_gas_multiplier(&mut self, multiplier: f32) {
-        self.nymd.set_simulated_gas_multiplier(multiplier)
-    }
 }
 
 #[cfg(feature = "nymd-client")]
@@ -264,14 +260,13 @@ impl<C> Client<C> {
         &self,
         address: String,
         mix_identity: IdentityKey,
-        proxy: Option<String>,
     ) -> Result<u128, ValidatorClientError>
     where
         C: CosmWasmClient + Sync,
     {
         Ok(self
             .nymd
-            .get_delegator_rewards(address, mix_identity, proxy)
+            .get_delegator_rewards(address, mix_identity)
             .await?
             .u128())
     }
@@ -279,14 +274,13 @@ impl<C> Client<C> {
     pub async fn get_pending_delegation_events(
         &self,
         owner_address: String,
-        proxy_address: Option<String>,
     ) -> Result<Vec<DelegationEvent>, ValidatorClientError>
     where
         C: CosmWasmClient + Sync,
     {
         Ok(self
             .nymd
-            .get_pending_delegation_events(owner_address, proxy_address)
+            .get_pending_delegation_events(owner_address)
             .await?)
     }
 

common/client-libs/validator-client/src/nymd/cosmwasm_client/client.rs

@@ -8,7 +8,9 @@ use crate::nymd::cosmwasm_client::types::{
 };
 use crate::nymd::error::NymdError;
 use async_trait::async_trait;
-use cosmrs::proto::cosmos::auth::v1beta1::{QueryAccountRequest, QueryAccountResponse};
+use cosmrs::proto::cosmos::auth::v1beta1::{
+    BaseAccount, QueryAccountRequest, QueryAccountResponse,
+};
 use cosmrs::proto::cosmos::bank::v1beta1::{
     QueryAllBalancesRequest, QueryAllBalancesResponse, QueryBalanceRequest, QueryBalanceResponse,
     QueryTotalSupplyRequest, QueryTotalSupplyResponse,
@@ -81,16 +83,21 @@ pub trait CosmWasmClient: rpc::Client {
             .make_abci_query::<_, QueryAccountResponse>(path, req)
             .await?;
 
-        res.account.map(TryFrom::try_from).transpose()
+        let base_account = res
+            .account
+            .map(|account| BaseAccount::decode(account.value.as_ref()))
+            .transpose()?;
+
+        base_account
+            .map(|base_account| base_account.try_into())
+            .transpose()
     }
 
     async fn get_sequence(&self, address: &AccountId) -> Result<SequenceResponse, NymdError> {
-        let account = self
+        let base_account = self
             .get_account(address)
             .await?
             .ok_or_else(|| NymdError::NonExistentAccountError(address.clone()))?;
-        let base_account = account.try_get_base_account()?;
-
         Ok(SequenceResponse {
             account_number: base_account.account_number,
             sequence: base_account.sequence,

common/client-libs/validator-client/src/nymd/cosmwasm_client/helpers.rs

@@ -3,9 +3,7 @@
 
 use crate::nymd::error::NymdError;
 use cosmrs::proto::cosmos::base::query::v1beta1::{PageRequest, PageResponse};
-use cosmrs::proto::cosmos::base::v1beta1::Coin as ProtoCoin;
 use cosmrs::rpc::endpoint::broadcast;
-use cosmrs::Coin;
 use flate2::write::GzEncoder;
 use flate2::Compression;
 use std::io::Write;
@@ -67,14 +65,3 @@ pub(crate) fn next_page_key(pagination_info: Option<PageResponse>) -> Option<Vec
 
     None
 }
-
-pub(crate) fn parse_proto_coin_vec(value: Vec<ProtoCoin>) -> Result<Vec<Coin>, NymdError> {
-    value
-        .into_iter()
-        .map(|proto_coin| {
-            Coin::try_from(&proto_coin).map_err(|_| NymdError::MalformedCoin {
-                coin_representation: format!("{:?}", proto_coin),
-            })
-        })
-        .collect()
-}

common/client-libs/validator-client/src/nymd/cosmwasm_client/types.rs

@@ -1,34 +1,23 @@
-// Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
 // TODO: There's a significant argument to pull those out of the package and make a PR on https://github.com/cosmos/cosmos-rust/
 
-use crate::nymd::cosmwasm_client::helpers::parse_proto_coin_vec;
 use crate::nymd::cosmwasm_client::logs::Log;
 use crate::nymd::error::NymdError;
 use cosmrs::crypto::PublicKey;
-use cosmrs::proto::cosmos::auth::v1beta1::{
-    BaseAccount as ProtoBaseAccount, ModuleAccount as ProtoModuleAccount,
-};
+use cosmrs::proto::cosmos::auth::v1beta1::BaseAccount;
 use cosmrs::proto::cosmos::base::abci::v1beta1::{
     GasInfo as ProtoGasInfo, Result as ProtoAbciResult,
 };
 use cosmrs::proto::cosmos::tx::v1beta1::SimulateResponse as ProtoSimulateResponse;
-use cosmrs::proto::cosmos::vesting::v1beta1::{
-    BaseVestingAccount as ProtoBaseVestingAccount,
-    ContinuousVestingAccount as ProtoContinuousVestingAccount,
-    DelayedVestingAccount as ProtoDelayedVestingAccount, Period as ProtoPeriod,
-    PeriodicVestingAccount as ProtoPeriodicVestingAccount,
-    PermanentLockedAccount as ProtoPermanentLockedAccount,
-};
 use cosmrs::proto::cosmwasm::wasm::v1::{
     CodeInfoResponse, ContractCodeHistoryEntry as ProtoContractCodeHistoryEntry,
     ContractCodeHistoryOperationType, ContractInfo as ProtoContractInfo,
 };
 use cosmrs::tendermint::{abci, chain};
 use cosmrs::tx::{AccountNumber, Gas, SequenceNumber};
-use cosmrs::{tx, AccountId, Any, Coin};
-use prost::Message;
+use cosmrs::{tx, AccountId, Coin};
 use serde::Serialize;
 use std::convert::{TryFrom, TryInto};
 
@@ -43,11 +32,8 @@ pub struct SequenceResponse {
     pub sequence: SequenceNumber,
 }
 
-/// BaseAccount defines a base account type. It contains all the necessary fields
-/// for basic account functionality. Any custom account type should extend this
-/// type for additional functionality (e.g. vesting).
 #[derive(Debug)]
-pub struct BaseAccount {
+pub struct Account {
     /// Bech32 account address
     pub address: AccountId,
     pub pubkey: Option<PublicKey>,
@@ -55,10 +41,10 @@ pub struct BaseAccount {
     pub sequence: SequenceNumber,
 }
 
-impl TryFrom<ProtoBaseAccount> for BaseAccount {
+impl TryFrom<BaseAccount> for Account {
     type Error = NymdError;
 
-    fn try_from(value: ProtoBaseAccount) -> Result<Self, Self::Error> {
+    fn try_from(value: BaseAccount) -> Result<Self, Self::Error> {
         let address: AccountId = value
             .address
             .parse()
@@ -70,7 +56,7 @@ impl TryFrom<ProtoBaseAccount> for BaseAccount {
             .transpose()
             .map_err(|_| NymdError::InvalidPublicKey(address.clone()))?;
 
-        Ok(BaseAccount {
+        Ok(Account {
             address,
             pubkey,
             account_number: value.account_number,
@@ -79,261 +65,6 @@ impl TryFrom<ProtoBaseAccount> for BaseAccount {
     }
 }
 
-/// ModuleAccount defines an account for modules that holds coins on a pool.
-#[derive(Debug)]
-pub struct ModuleAccount {
-    pub base_account: Option<BaseAccount>,
-    pub name: String,
-    pub permissions: Vec<String>,
-}
-
-impl TryFrom<ProtoModuleAccount> for ModuleAccount {
-    type Error = NymdError;
-
-    fn try_from(value: ProtoModuleAccount) -> Result<Self, Self::Error> {
-        let base_account = value.base_account.map(TryFrom::try_from).transpose()?;
-
-        Ok(ModuleAccount {
-            base_account,
-            name: value.name,
-            permissions: value.permissions,
-        })
-    }
-}
-
-/// BaseVestingAccount implements the VestingAccount interface. It contains all
-/// the necessary fields needed for any vesting account implementation.
-#[derive(Debug)]
-pub struct BaseVestingAccount {
-    pub base_account: Option<BaseAccount>,
-    pub original_vesting: Vec<Coin>,
-    pub delegated_free: Vec<Coin>,
-    pub delegated_vesting: Vec<Coin>,
-    pub end_time: i64,
-}
-
-impl TryFrom<ProtoBaseVestingAccount> for BaseVestingAccount {
-    type Error = NymdError;
-
-    fn try_from(value: ProtoBaseVestingAccount) -> Result<Self, Self::Error> {
-        let base_account = value.base_account.map(TryFrom::try_from).transpose()?;
-
-        let original_vesting = parse_proto_coin_vec(value.original_vesting)?;
-        let delegated_free = parse_proto_coin_vec(value.delegated_free)?;
-        let delegated_vesting = parse_proto_coin_vec(value.delegated_vesting)?;
-
-        Ok(BaseVestingAccount {
-            base_account,
-            original_vesting,
-            delegated_free,
-            delegated_vesting,
-            end_time: value.end_time,
-        })
-    }
-}
-
-/// ContinuousVestingAccount implements the VestingAccount interface. It
-/// continuously vests by unlocking coins linearly with respect to time.
-#[derive(Debug)]
-pub struct ContinuousVestingAccount {
-    pub base_vesting_account: Option<BaseVestingAccount>,
-    pub start_time: i64,
-}
-
-impl TryFrom<ProtoContinuousVestingAccount> for ContinuousVestingAccount {
-    type Error = NymdError;
-
-    fn try_from(value: ProtoContinuousVestingAccount) -> Result<Self, Self::Error> {
-        let base_vesting_account = value
-            .base_vesting_account
-            .map(TryFrom::try_from)
-            .transpose()?;
-
-        Ok(ContinuousVestingAccount {
-            base_vesting_account,
-            start_time: value.start_time,
-        })
-    }
-}
-
-/// DelayedVestingAccount implements the VestingAccount interface. It vests all
-/// coins after a specific time, but non prior. In other words, it keeps them
-/// locked until a specified time.
-#[derive(Debug)]
-pub struct DelayedVestingAccount {
-    pub base_vesting_account: Option<BaseVestingAccount>,
-}
-
-impl TryFrom<ProtoDelayedVestingAccount> for DelayedVestingAccount {
-    type Error = NymdError;
-
-    fn try_from(value: ProtoDelayedVestingAccount) -> Result<Self, Self::Error> {
-        let base_vesting_account = value
-            .base_vesting_account
-            .map(TryFrom::try_from)
-            .transpose()?;
-
-        Ok(DelayedVestingAccount {
-            base_vesting_account,
-        })
-    }
-}
-
-/// Period defines a length of time and amount of coins that will vest.
-#[derive(Debug)]
-pub struct Period {
-    pub length: i64,
-    pub amount: Vec<Coin>,
-}
-
-impl TryFrom<ProtoPeriod> for Period {
-    type Error = NymdError;
-
-    fn try_from(value: ProtoPeriod) -> Result<Self, Self::Error> {
-        Ok(Period {
-            length: value.length,
-            amount: parse_proto_coin_vec(value.amount)?,
-        })
-    }
-}
-
-/// PeriodicVestingAccount implements the VestingAccount interface. It
-/// periodically vests by unlocking coins during each specified period.
-#[derive(Debug)]
-pub struct PeriodicVestingAccount {
-    pub base_vesting_account: Option<BaseVestingAccount>,
-    pub start_time: i64,
-    pub vesting_periods: Vec<Period>,
-}
-
-impl TryFrom<ProtoPeriodicVestingAccount> for PeriodicVestingAccount {
-    type Error = NymdError;
-
-    fn try_from(value: ProtoPeriodicVestingAccount) -> Result<Self, Self::Error> {
-        let base_vesting_account = value
-            .base_vesting_account
-            .map(TryFrom::try_from)
-            .transpose()?;
-
-        let vesting_periods = value
-            .vesting_periods
-            .into_iter()
-            .map(TryFrom::try_from)
-            .collect::<Result<_, _>>()?;
-
-        Ok(PeriodicVestingAccount {
-            base_vesting_account,
-            start_time: value.start_time,
-            vesting_periods,
-        })
-    }
-}
-
-/// PermanentLockedAccount implements the VestingAccount interface. It does
-/// not ever release coins, locking them indefinitely. Coins in this account can
-/// still be used for delegating and for governance votes even while locked.
-#[derive(Debug)]
-pub struct PermanentLockedAccount {
-    pub base_vesting_account: Option<BaseVestingAccount>,
-}
-
-impl TryFrom<ProtoPermanentLockedAccount> for PermanentLockedAccount {
-    type Error = NymdError;
-
-    fn try_from(value: ProtoPermanentLockedAccount) -> Result<Self, Self::Error> {
-        let base_vesting_account = value
-            .base_vesting_account
-            .map(TryFrom::try_from)
-            .transpose()?;
-
-        Ok(PermanentLockedAccount {
-            base_vesting_account,
-        })
-    }
-}
-
-#[derive(Debug)]
-pub enum Account {
-    Base(BaseAccount),
-    Module(ModuleAccount),
-    BaseVesting(BaseVestingAccount),
-    ContinuousVesting(ContinuousVestingAccount),
-    DelayedVesting(DelayedVestingAccount),
-    PeriodicVesting(PeriodicVestingAccount),
-    PermanentLockedVesting(PermanentLockedAccount),
-}
-
-impl Account {
-    pub fn try_get_base_account(&self) -> Result<&BaseAccount, NymdError> {
-        match self {
-            Account::Base(acc) => Ok(acc),
-            Account::Module(acc) => acc
-                .base_account
-                .as_ref()
-                .ok_or(NymdError::NoBaseAccountInformationAvailable),
-            Account::BaseVesting(acc) => acc
-                .base_account
-                .as_ref()
-                .ok_or(NymdError::NoBaseAccountInformationAvailable),
-            Account::ContinuousVesting(acc) => acc
-                .base_vesting_account
-                .as_ref()
-                .and_then(|vesting_acc| vesting_acc.base_account.as_ref())
-                .ok_or(NymdError::NoBaseAccountInformationAvailable),
-            Account::DelayedVesting(acc) => acc
-                .base_vesting_account
-                .as_ref()
-                .and_then(|vesting_acc| vesting_acc.base_account.as_ref())
-                .ok_or(NymdError::NoBaseAccountInformationAvailable),
-            Account::PeriodicVesting(acc) => acc
-                .base_vesting_account
-                .as_ref()
-                .and_then(|vesting_acc| vesting_acc.base_account.as_ref())
-                .ok_or(NymdError::NoBaseAccountInformationAvailable),
-            Account::PermanentLockedVesting(acc) => acc
-                .base_vesting_account
-                .as_ref()
-                .and_then(|vesting_acc| vesting_acc.base_account.as_ref())
-                .ok_or(NymdError::NoBaseAccountInformationAvailable),
-        }
-    }
-}
-
-impl TryFrom<Any> for Account {
-    type Error = NymdError;
-
-    fn try_from(raw_account: Any) -> Result<Self, Self::Error> {
-        match raw_account.type_url.as_ref() {
-            "/cosmos.auth.v1beta1.BaseAccount" => Ok(Account::Base(
-                ProtoBaseAccount::decode(raw_account.value.as_ref())?.try_into()?,
-            )),
-            "/cosmos.auth.v1beta1.ModuleAccount" => Ok(Account::Module(
-                ProtoModuleAccount::decode(raw_account.value.as_ref())?.try_into()?,
-            )),
-            "/cosmos.vesting.v1beta1.BaseVestingAccount" => Ok(Account::BaseVesting(
-                ProtoBaseVestingAccount::decode(raw_account.value.as_ref())?.try_into()?,
-            )),
-            "/cosmos.vesting.v1beta1.ContinuousVestingAccount" => Ok(Account::ContinuousVesting(
-                ProtoContinuousVestingAccount::decode(raw_account.value.as_ref())?.try_into()?,
-            )),
-            "/cosmos.vesting.v1beta1.DelayedVestingAccount" => Ok(Account::DelayedVesting(
-                ProtoDelayedVestingAccount::decode(raw_account.value.as_ref())?.try_into()?,
-            )),
-            "/cosmos.vesting.v1beta1.PeriodicVestingAccount" => Ok(Account::PeriodicVesting(
-                ProtoPeriodicVestingAccount::decode(raw_account.value.as_ref())?.try_into()?,
-            )),
-            "/cosmos.vesting.v1beta1.PermanentLockedAccount" => {
-                Ok(Account::PermanentLockedVesting(
-                    ProtoPermanentLockedAccount::decode(raw_account.value.as_ref())?.try_into()?,
-                ))
-            }
-            _ => Err(NymdError::UnsupportedAccountType {
-                type_url: raw_account.type_url,
-            }),
-        }
-    }
-}
-
 #[derive(Debug)]
 pub struct Code {
     pub code_id: ContractCodeId,

common/client-libs/validator-client/src/nymd/error.rs

@@ -108,15 +108,6 @@ pub enum NymdError {
 
     #[error("Abci query failed with code {0} - {1}")]
     AbciError(u32, abci::Log),
-
-    #[error("Unsupported account type: {type_url}")]
-    UnsupportedAccountType { type_url: String },
-
-    #[error("{coin_representation} is not a valid Cosmos Coin")]
-    MalformedCoin { coin_representation: String },
-
-    #[error("This account does not have BaseAccount information available to it")]
-    NoBaseAccountInformationAvailable,
 }
 
 impl NymdError {

common/client-libs/validator-client/src/nymd/mod.rs

@@ -3,8 +3,8 @@
 
 use crate::nymd::cosmwasm_client::signing_client;
 use crate::nymd::cosmwasm_client::types::{
-    Account, ChangeAdminResult, ContractCodeId, ExecuteResult, InstantiateOptions,
-    InstantiateResult, MigrateResult, SequenceResponse, UploadResult,
+    ChangeAdminResult, ContractCodeId, ExecuteResult, InstantiateOptions, InstantiateResult,
+    MigrateResult, SequenceResponse, UploadResult,
 };
 use crate::nymd::error::NymdError;
 use crate::nymd::wallet::DirectSecp256k1HdWallet;
@@ -171,10 +171,6 @@ impl<C> NymdClient<C> {
             .ok_or(NymdError::NoContractAddressAvailable)
     }
 
-    pub fn set_simulated_gas_multiplier(&mut self, multiplier: f32) {
-        self.simulated_gas_multiplier = multiplier;
-    }
-
     pub fn address(&self) -> &AccountId
     where
         C: SigningCosmWasmClient,
@@ -230,16 +226,6 @@ impl<C> NymdClient<C> {
         self.client.get_sequence(self.address()).await
     }
 
-    pub async fn get_account_details(
-        &self,
-        address: &AccountId,
-    ) -> Result<Option<Account>, NymdError>
-    where
-        C: SigningCosmWasmClient + Sync,
-    {
-        self.client.get_account(address).await
-    }
-
     pub async fn get_current_block_timestamp(&self) -> Result<TendermintTime, NymdError>
     where
         C: CosmWasmClient + Sync,
@@ -329,7 +315,6 @@ impl<C> NymdClient<C> {
         &self,
         address: String,
         mix_identity: IdentityKey,
-        proxy: Option<String>,
     ) -> Result<Uint128, NymdError>
     where
         C: CosmWasmClient + Sync,
@@ -337,7 +322,6 @@ impl<C> NymdClient<C> {
         let request = QueryMsg::QueryDelegatorReward {
             address,
             mix_identity,
-            proxy,
         };
         self.client
             .query_contract_smart(self.mixnet_contract_address()?, &request)
@@ -347,15 +331,11 @@ impl<C> NymdClient<C> {
     pub async fn get_pending_delegation_events(
         &self,
         owner_address: String,
-        proxy_address: Option<String>,
     ) -> Result<Vec<DelegationEvent>, NymdError>
     where
         C: CosmWasmClient + Sync,
     {
-        let request = QueryMsg::GetPendingDelegationEvents {
-            owner_address,
-            proxy_address,
-        };
+        let request = QueryMsg::GetPendingDelegationEvents { owner_address };
         self.client
             .query_contract_smart(self.mixnet_contract_address()?, &request)
             .await

common/client-libs/validator-client/src/nymd/traits/vesting_signing_client.rs

@@ -256,7 +256,7 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
                 self.vesting_contract_address()?,
                 &req,
                 fee,
-                "VestingContract::DelegateToMixnode",
+                "VestingContract::DeledateToMixnode",
                 vec![],
             )
             .await

common/coconut-interface/src/error.rs

@@ -10,10 +10,4 @@ pub enum CoconutInterfaceError {
 
     #[error("Could not decode base 58 string - {0}")]
     MalformedString(#[from] bs58::decode::Error),
-
-    #[error("Not enough public attributes were specified")]
-    NotEnoughPublicAttributes,
-
-    #[error("Could not recover bandwidth value")]
-    InvalidBandwidth,
 }

common/coconut-interface/src/lib.rs

@@ -5,7 +5,6 @@ pub mod error;
 
 use getset::{CopyGetters, Getters};
 use serde::{Deserialize, Serialize};
-use std::str::FromStr;
 
 use error::CoconutInterfaceError;
 
@@ -25,11 +24,9 @@ impl Credential {
     pub fn new(
         n_params: u32,
         theta: Theta,
-        voucher_value: String,
-        voucher_info: String,
+        public_attributes: Vec<Vec<u8>>,
         signature: &Signature,
     ) -> Credential {
-        let public_attributes = vec![voucher_value.into_bytes(), voucher_info.into_bytes()];
         Credential {
             n_params,
             theta,
@@ -38,18 +35,8 @@ impl Credential {
         }
     }
 
-    pub fn voucher_value(&self) -> Result<u64, CoconutInterfaceError> {
-        let bandwidth_vec = self
-            .public_attributes
-            .get(0)
-            .ok_or(CoconutInterfaceError::NotEnoughPublicAttributes)?
-            .to_owned();
-        let bandwidth_str = String::from_utf8(bandwidth_vec)
-            .map_err(|_| CoconutInterfaceError::InvalidBandwidth)?;
-        let value =
-            u64::from_str(&bandwidth_str).map_err(|_| CoconutInterfaceError::InvalidBandwidth)?;
-
-        Ok(value)
+    pub fn public_attributes(&self) -> Vec<Vec<u8>> {
+        self.public_attributes.clone()
     }
 
     pub fn verify(&self, verification_key: &VerificationKey) -> bool {

common/config/src/lib.rs

@@ -4,8 +4,6 @@
 use handlebars::Handlebars;
 use serde::de::DeserializeOwned;
 use serde::Serialize;
-#[cfg(unix)]
-use std::os::unix::fs::PermissionsExt;
 use std::path::PathBuf;
 use std::{fs, io};
 
@@ -66,19 +64,11 @@ pub trait NymConfig: Default + Serialize + DeserializeOwned {
             None => fs::create_dir_all(self.config_directory()),
         }?;
 
-        let location = custom_location
-            .unwrap_or_else(|| self.config_directory().join(Self::config_file_name()));
-
-        fs::write(location.clone(), templated_config)?;
-
-        #[cfg(unix)]
-        let mut perms = fs::metadata(location.clone())?.permissions();
-        #[cfg(unix)]
-        perms.set_mode(0o600);
-        #[cfg(unix)]
-        fs::set_permissions(location, perms)?;
-
-        Ok(())
+        fs::write(
+            custom_location
+                .unwrap_or_else(|| self.config_directory().join(Self::config_file_name())),
+            templated_config,
+        )
     }
 
     fn load_from_file(id: Option<&str>) -> io::Result<Self> {

common/cosmwasm-smart-contracts/coconut-bandwidth-contract/Cargo.toml

@@ -6,6 +6,5 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-cosmwasm-std = "1.0.0-beta6"
 schemars = "0.8"
 serde = { version = "1.0.103", default-features = false, features = ["derive"] }

common/cosmwasm-smart-contracts/coconut-bandwidth-contract/src/msg.rs

@@ -1,23 +1,18 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use cosmwasm_std::Coin;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use crate::deposit::DepositData;
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
-pub struct InstantiateMsg {
-    pub multisig_addr: String,
-    pub pool_addr: String,
-}
+pub struct InstantiateMsg {}
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum ExecuteMsg {
     DepositFunds { data: DepositData },
-    ReleaseFunds { funds: Coin },
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]

common/cosmwasm-smart-contracts/contracts-common/Cargo.toml

@@ -7,4 +7,4 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-cosmwasm-std = "1.0.0-beta8"
+cosmwasm-std = "1.0.0-beta6"

common/cosmwasm-smart-contracts/mixnet-contract/Cargo.toml

@@ -7,7 +7,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-cosmwasm-std = "1.0.0-beta8"
+cosmwasm-std = "1.0.0-beta6"
 
 serde = { version = "1.0", features = ["derive"] }
 serde_repr = "0.1"

common/cosmwasm-smart-contracts/mixnet-contract/src/interval.rs

@@ -2,9 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use cosmwasm_std::Env;
-use schemars::gen::SchemaGenerator;
-use schemars::schema::{InstanceType, Schema, SchemaObject};
-use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::convert::TryInto;
 use std::fmt::{Display, Formatter};
@@ -67,39 +64,6 @@ pub struct Interval {
     length: Duration,
 }
 
-impl JsonSchema for Interval {
-    fn schema_name() -> String {
-        "Interval".to_owned()
-    }
-
-    fn json_schema(gen: &mut SchemaGenerator) -> Schema {
-        let mut schema_object = SchemaObject {
-            instance_type: Some(InstanceType::Object.into()),
-            ..SchemaObject::default()
-        };
-
-        let object_validation = schema_object.object();
-        object_validation
-            .properties
-            .insert("id".to_owned(), gen.subschema_for::<u32>());
-        object_validation.required.insert("id".to_owned());
-
-        // PrimitiveDateTime does not implement JsonSchema. However it has a custom
-        // serialization to string, so we just specify the schema to be String.
-        object_validation
-            .properties
-            .insert("start".to_owned(), gen.subschema_for::<String>());
-        object_validation.required.insert("start".to_owned());
-
-        object_validation
-            .properties
-            .insert("length".to_owned(), gen.subschema_for::<Duration>());
-        object_validation.required.insert("length".to_owned());
-
-        Schema::Object(schema_object)
-    }
-}
-
 impl Interval {
     /// Initialize epoch in the contract with default values.
     pub fn init_epoch(env: Env) -> Self {

common/cosmwasm-smart-contracts/mixnet-contract/src/mixnode.rs

@@ -228,7 +228,7 @@ impl DelegatorRewardParams {
 
         let scaled_delegation_amount = delegation_amount / circulating_supply;
         let delegator_reward =
-            (ONE - self.profit_margin) * (scaled_delegation_amount / self.sigma) * self.node_profit;
+            (ONE - self.profit_margin) * scaled_delegation_amount / self.sigma * self.node_profit;
 
         let reward = delegator_reward.max(U128::ZERO);
         if let Some(int_reward) = reward.checked_cast() {
@@ -426,17 +426,17 @@ impl MixNodeBond {
         &self,
         params: &RewardParams,
     ) -> Result<(u64, u64, u64), MixnetContractError> {
-        let total_node_reward = self
-            .reward(params)
-            .reward()
-            .checked_to_num::<u128>()
-            .unwrap_or_default();
+        let total_node_reward = self.reward(params);
         let operator_reward = self.operator_reward(params);
-        // Total reward has to be the sum of operator and delegator rewards
-        let delegators_reward = total_node_reward - operator_reward;
+        // TODO: This overestimates the reward by a lot, it should take a Uint128 and return estiamte for that
+        let delegators_reward = self.reward_delegation(self.total_delegation().amount, params);
 
         Ok((
-            total_node_reward.try_into()?,
+            total_node_reward
+                .reward()
+                .checked_to_num::<u128>()
+                .unwrap_or_default()
+                .try_into()?,
             operator_reward.try_into()?,
             delegators_reward.try_into()?,
         ))

common/cosmwasm-smart-contracts/mixnet-contract/src/msg.rs

@@ -171,11 +171,9 @@ pub enum QueryMsg {
     QueryDelegatorReward {
         address: String,
         mix_identity: IdentityKey,
-        proxy: Option<String>,
     },
     GetPendingDelegationEvents {
         owner_address: String,
-        proxy_address: Option<String>,
     },
 }
 

common/cosmwasm-smart-contracts/vesting-contract/Cargo.toml

@@ -6,11 +6,11 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-cosmwasm-std = "1.0.0-beta8"
+cosmwasm-std = "1.0.0-beta6"
 mixnet-contract-common = { path = "../mixnet-contract" }
 serde = { version = "1.0", features = ["derive"] }
 schemars = "0.8"
-cw-storage-plus = "0.13.2"
+cw-storage-plus = "0.13.1"
 config = { path = "../../config" }
 
 [dev-dependencies]

common/cosmwasm-smart-contracts/vesting-contract/src/messages.rs

@@ -49,10 +49,6 @@ impl VestingSpecification {
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum ExecuteMsg {
-    CompoundDelegatorReward {
-        mix_identity: String,
-    },
-    CompoundOperatorReward {},
     UpdateMixnodeConfig {
         profit_margin_percent: u8,
     },

common/credential-storage/Cargo.toml

@@ -1,20 +0,0 @@
-[package]
-name = "credential-storage"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-async-trait = { version = "0.1.51" }
-nymcoconut = { path = "../nymcoconut" }
-
-log = "0.4"
-sqlx = { version = "0.5", features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"]}
-thiserror = "1.0"
-tokio = { version = "1.4", features = [ "rt-multi-thread", "net", "signal", "fs" ] }
-
-
-[build-dependencies]
-sqlx = { version = "0.5", features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"] }
-tokio = { version = "1.4", features = ["rt-multi-thread", "macros"] }

common/credential-storage/build.rs

@@ -1,30 +0,0 @@
-/*
- * Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
- * SPDX-License-Identifier: Apache-2.0
- */
-
-use sqlx::{Connection, SqliteConnection};
-use std::env;
-
-#[tokio::main]
-async fn main() {
-    let out_dir = env::var("OUT_DIR").unwrap();
-    let database_path = format!("{}/coconut-credential-example.sqlite", out_dir);
-
-    let mut conn = SqliteConnection::connect(&*format!("sqlite://{}?mode=rwc", database_path))
-        .await
-        .expect("Failed to create SQLx database connection");
-
-    sqlx::migrate!("./migrations")
-        .run(&mut conn)
-        .await
-        .expect("Failed to perform SQLx migrations");
-
-    #[cfg(target_family = "unix")]
-    println!("cargo:rustc-env=DATABASE_URL=sqlite://{}", &database_path);
-
-    #[cfg(target_family = "windows")]
-    // for some strange reason we need to add a leading `/` to the windows path even though it's
-    // not a valid windows path... but hey, it works...
-    println!("cargo:rustc-env=DATABASE_URL=sqlite:///{}", &database_path);
-}

common/credential-storage/migrations/20220408120000_initial_tables.sql

@@ -1,22 +0,0 @@
-/*
- * Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
- * SPDX-License-Identifier: Apache-2.0
- */
-
-CREATE TABLE coconut_credentials
-(
-    id                  INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
-    voucher_value       TEXT    NOT NULL,
-    voucher_info        TEXT    NOT NULL,
-    serial_number       TEXT    NOT NULL,
-    binding_number      TEXT    NOT NULL,
-    signature           TEXT    NOT NULL UNIQUE
-);
-
-CREATE TABLE erc20_credentials
-(
-    id                  INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
-    public_key          TEXT    NOT NULL,
-    private_key         TEXT    NOT NULL,
-    consumed            BOOLEAN NOT NULL
-);

common/credential-storage/src/coconut.rs

@@ -1,67 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::models::CoconutCredential;
-
-#[derive(Clone)]
-pub(crate) struct CoconutCredentialManager {
-    connection_pool: sqlx::SqlitePool,
-}
-
-impl CoconutCredentialManager {
-    /// Creates new instance of the `CoconutCredentialManager` with the provided sqlite connection pool.
-    ///
-    /// # Arguments
-    ///
-    /// * `connection_pool`: database connection pool to use.
-    pub(crate) fn new(connection_pool: sqlx::SqlitePool) -> Self {
-        CoconutCredentialManager { connection_pool }
-    }
-
-    /// Inserts provided signature into the database.
-    ///
-    /// # Arguments
-    ///
-    /// * `voucher_value`: Plaintext bandwidth value of the credential.
-    /// * `voucher_info`: Plaintext information of the credential.
-    /// * `serial_number`: Base58 representation of the serial number attribute.
-    /// * `binding_number`: Base58 representation of the binding number attribute.
-    /// * `signature`: Coconut credential in the form of a signature.
-    pub(crate) async fn insert_coconut_credential(
-        &self,
-        voucher_value: String,
-        voucher_info: String,
-        serial_number: String,
-        binding_number: String,
-        signature: String,
-    ) -> Result<(), sqlx::Error> {
-        sqlx::query!(
-            "INSERT INTO coconut_credentials(voucher_value, voucher_info, serial_number, binding_number, signature) VALUES (?, ?, ?, ?, ?)",
-            voucher_value, voucher_info, serial_number, binding_number, signature
-        )
-        .execute(&self.connection_pool)
-        .await?;
-        Ok(())
-    }
-
-    /// Tries to retrieve one of the stored, unused credentials.
-    pub(crate) async fn get_next_coconut_credential(
-        &self,
-    ) -> Result<CoconutCredential, sqlx::Error> {
-        sqlx::query_as!(CoconutCredential, "SELECT * FROM coconut_credentials")
-            .fetch_one(&self.connection_pool)
-            .await
-    }
-
-    /// Removes from the database the specified credential.
-    ///
-    /// # Arguments
-    ///
-    /// * `id`: Database id.
-    pub(crate) async fn remove_coconut_credential(&self, id: i64) -> Result<(), sqlx::Error> {
-        sqlx::query!("DELETE FROM coconut_credentials WHERE id = ?", id)
-            .execute(&self.connection_pool)
-            .await?;
-        Ok(())
-    }
-}

common/credential-storage/src/erc20.rs

@@ -1,71 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::models::ERC20Credential;
-
-#[derive(Clone)]
-pub(crate) struct ERC20CredentialManager {
-    connection_pool: sqlx::SqlitePool,
-}
-
-impl ERC20CredentialManager {
-    /// Creates new instance of the `ERC20CredentialManager` with the provided sqlite connection pool.
-    ///
-    /// # Arguments
-    ///
-    /// * `connection_pool`: database connection pool to use.
-    pub(crate) fn new(connection_pool: sqlx::SqlitePool) -> Self {
-        ERC20CredentialManager { connection_pool }
-    }
-
-    /// Inserts provided signature into the database.
-    ///
-    /// # Arguments
-    ///
-    /// * `public_key`: Base58 representation of a public key.
-    /// * `private_key`: Base58 representation of a private key.
-    pub(crate) async fn insert_erc20_credential(
-        &self,
-        public_key: String,
-        private_key: String,
-    ) -> Result<(), sqlx::Error> {
-        sqlx::query!(
-            "INSERT INTO erc20_credentials(public_key, private_key, consumed) VALUES (?, ?, ?)",
-            public_key,
-            private_key,
-            false,
-        )
-        .execute(&self.connection_pool)
-        .await?;
-        Ok(())
-    }
-
-    /// Tries to retrieve one of the stored, unused credentials.
-    pub(crate) async fn get_next_erc20_credential(&self) -> Result<ERC20Credential, sqlx::Error> {
-        sqlx::query_as!(
-            ERC20Credential,
-            "SELECT * FROM erc20_credentials WHERE consumed = false"
-        )
-        .fetch_one(&self.connection_pool)
-        .await
-    }
-
-    /// Mark a credential as being consumed.
-    pub(crate) async fn consume_erc20_credential(
-        &self,
-        public_key: String,
-    ) -> Result<(), sqlx::Error> {
-        sqlx::query!(
-            r#"
-                UPDATE erc20_credentials
-                SET consumed = true
-                WHERE public_key = ?
-            "#,
-            public_key
-        )
-        .execute(&self.connection_pool)
-        .await?;
-
-        Ok(())
-    }
-}

common/credential-storage/src/error.rs

@@ -1,16 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use thiserror::Error;
-
-#[derive(Error, Debug)]
-pub enum StorageError {
-    #[error("Database experienced an internal error - {0}")]
-    InternalDatabaseError(#[from] sqlx::Error),
-
-    #[error("Failed to perform database migration - {0}")]
-    MigrationError(#[from] sqlx::migrate::MigrateError),
-
-    #[error("Inconsistent data in database")]
-    InconsistentData,
-}

common/credential-storage/src/lib.rs

@@ -1,144 +0,0 @@
-/*
- * Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
- * SPDX-License-Identifier: Apache-2.0
- */
-
-use crate::coconut::CoconutCredentialManager;
-use crate::erc20::ERC20CredentialManager;
-use crate::error::StorageError;
-use crate::storage::Storage;
-
-use crate::models::{CoconutCredential, ERC20Credential};
-use async_trait::async_trait;
-use log::{debug, error};
-use sqlx::ConnectOptions;
-use std::path::{Path, PathBuf};
-
-mod coconut;
-mod erc20;
-pub mod error;
-mod models;
-pub mod storage;
-
-// note that clone here is fine as upon cloning the same underlying pool will be used
-#[derive(Clone)]
-pub struct PersistentStorage {
-    coconut_credential_manager: CoconutCredentialManager,
-    erc20_credential_manager: ERC20CredentialManager,
-}
-
-impl PersistentStorage {
-    /// Initialises `PersistentStorage` using the provided path.
-    ///
-    /// # Arguments
-    ///
-    /// * `database_path`: path to the database.
-    pub async fn init<P: AsRef<Path> + Send>(database_path: P) -> Result<Self, StorageError> {
-        debug!(
-            "Attempting to connect to database {:?}",
-            database_path.as_ref().as_os_str()
-        );
-
-        let mut opts = sqlx::sqlite::SqliteConnectOptions::new()
-            .filename(database_path)
-            .create_if_missing(true);
-
-        opts.disable_statement_logging();
-
-        let connection_pool = match sqlx::SqlitePool::connect_with(opts).await {
-            Ok(db) => db,
-            Err(err) => {
-                error!("Failed to connect to SQLx database: {}", err);
-                return Err(err.into());
-            }
-        };
-
-        if let Err(err) = sqlx::migrate!("./migrations").run(&connection_pool).await {
-            error!("Failed to perform migration on the SQLx database: {}", err);
-            return Err(err.into());
-        }
-
-        Ok(PersistentStorage {
-            coconut_credential_manager: CoconutCredentialManager::new(connection_pool.clone()),
-            erc20_credential_manager: ERC20CredentialManager::new(connection_pool),
-        })
-    }
-}
-
-#[async_trait]
-impl Storage for PersistentStorage {
-    async fn insert_coconut_credential(
-        &self,
-        voucher_value: String,
-        voucher_info: String,
-        serial_number: String,
-        binding_number: String,
-        signature: String,
-    ) -> Result<(), StorageError> {
-        self.coconut_credential_manager
-            .insert_coconut_credential(
-                voucher_value,
-                voucher_info,
-                serial_number,
-                binding_number,
-                signature,
-            )
-            .await?;
-
-        Ok(())
-    }
-
-    async fn get_next_coconut_credential(&self) -> Result<CoconutCredential, StorageError> {
-        let credential = self
-            .coconut_credential_manager
-            .get_next_coconut_credential()
-            .await?;
-
-        Ok(credential)
-    }
-
-    async fn remove_coconut_credential(&self, id: i64) -> Result<(), StorageError> {
-        self.coconut_credential_manager
-            .remove_coconut_credential(id)
-            .await?;
-
-        Ok(())
-    }
-
-    async fn insert_erc20_credential(
-        &self,
-        public_key: String,
-        private_key: String,
-    ) -> Result<(), StorageError> {
-        self.erc20_credential_manager
-            .insert_erc20_credential(public_key, private_key)
-            .await?;
-
-        Ok(())
-    }
-
-    async fn get_next_erc20_credential(&self) -> Result<ERC20Credential, StorageError> {
-        let credential = self
-            .erc20_credential_manager
-            .get_next_erc20_credential()
-            .await?;
-
-        Ok(credential)
-    }
-
-    async fn consume_erc20_credential(&self, public_key: String) -> Result<(), StorageError> {
-        let credential = self
-            .erc20_credential_manager
-            .consume_erc20_credential(public_key)
-            .await?;
-
-        Ok(credential)
-    }
-}
-
-pub async fn initialise_storage(path: PathBuf) -> PersistentStorage {
-    match PersistentStorage::init(path).await {
-        Err(err) => panic!("failed to initialise credential storage - {}", err),
-        Ok(storage) => storage,
-    }
-}

common/credential-storage/src/models.rs

@@ -1,20 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub struct CoconutCredential {
-    #[allow(dead_code)]
-    pub id: i64,
-    pub voucher_value: String,
-    pub voucher_info: String,
-    pub serial_number: String,
-    pub binding_number: String,
-    pub signature: String,
-}
-
-pub struct ERC20Credential {
-    #[allow(dead_code)]
-    pub id: i64,
-    pub public_key: String,
-    pub private_key: String,
-    pub consumed: bool,
-}

common/credential-storage/src/storage.rs

@@ -1,52 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use async_trait::async_trait;
-
-use crate::models::{CoconutCredential, ERC20Credential};
-use crate::StorageError;
-
-#[async_trait]
-pub trait Storage: Send + Sync {
-    /// Inserts provided signature into the database.
-    ///
-    /// # Arguments
-    ///
-    /// * `signature`: Coconut credential in the form of a signature.
-    async fn insert_coconut_credential(
-        &self,
-        voucher_value: String,
-        voucher_info: String,
-        serial_number: String,
-        binding_number: String,
-        signature: String,
-    ) -> Result<(), StorageError>;
-
-    /// Tries to retrieve one of the stored, unused credentials.
-    async fn get_next_coconut_credential(&self) -> Result<CoconutCredential, StorageError>;
-
-    /// Removes from the database the specified credential.
-    ///
-    /// # Arguments
-    ///
-    /// * `signature`: Coconut credential in the form of a signature.
-    async fn remove_coconut_credential(&self, id: i64) -> Result<(), StorageError>;
-
-    /// Inserts provided signature into the database.
-    ///
-    /// # Arguments
-    ///
-    /// * `public_key`: Base58 representation of a public key.
-    /// * `private_key`: Base58 representation of a private key.
-    async fn insert_erc20_credential(
-        &self,
-        public_key: String,
-        private_key: String,
-    ) -> Result<(), StorageError>;
-
-    /// Tries to retrieve one of the stored, unused credential data.
-    async fn get_next_erc20_credential(&self) -> Result<ERC20Credential, StorageError>;
-
-    /// Mark a credential as being consumed.
-    async fn consume_erc20_credential(&self, public_key: String) -> Result<(), StorageError>;
-}

common/credentials/src/coconut/bandwidth.rs

@@ -11,6 +11,7 @@ use coconut_interface::{
     PrivateAttribute, PublicAttribute, Signature, VerificationKey,
 };
 use crypto::asymmetric::{encryption, identity};
+use network_defaults::BANDWIDTH_VALUE;
 
 use cosmrs::tx::Hash;
 
@@ -158,27 +159,29 @@ impl BandwidthVoucher {
 
     pub fn sign(&self, request: &BlindSignRequest) -> identity::Signature {
         let mut message = request.to_bytes();
-        message.extend_from_slice(self.tx_hash.to_string().as_bytes());
+        message.extend_from_slice(self.tx_hash.as_bytes());
         self.signing_key.sign(&message)
     }
 }
 
 pub fn prepare_for_spending(
-    voucher_value: u64,
-    voucher_info: String,
-    serial_number: PrivateAttribute,
-    binding_number: PrivateAttribute,
+    raw_identity: &[u8],
     signature: &Signature,
+    attributes: &BandwidthVoucher,
     verification_key: &VerificationKey,
 ) -> Result<Credential, Error> {
+    let public_attributes = vec![
+        raw_identity.to_vec(),
+        BANDWIDTH_VALUE.to_be_bytes().to_vec(),
+    ];
+
     let params = Parameters::new(TOTAL_ATTRIBUTES)?;
 
     prepare_credential_for_spending(
         &params,
-        voucher_value,
-        voucher_info,
-        serial_number,
-        binding_number,
+        public_attributes,
+        attributes.serial_number,
+        attributes.binding_number,
         signature,
         verification_key,
     )

common/credentials/src/coconut/utils.rs

@@ -11,7 +11,7 @@ use crypto::shared_key::recompute_shared_key;
 use crypto::symmetric::stream_cipher;
 use url::Url;
 
-use crate::coconut::bandwidth::{BandwidthVoucher, PRIVATE_ATTRIBUTES, PUBLIC_ATTRIBUTES};
+use crate::coconut::bandwidth::{BandwidthVoucher, PRIVATE_ATTRIBUTES};
 use crate::coconut::params::{
     ValidatorApiCredentialEncryptionAlgorithm, ValidatorApiCredentialHkdfAlgorithm,
 };
@@ -175,8 +175,7 @@ pub async fn obtain_aggregate_signature(
 // TODO: better type flow
 pub fn prepare_credential_for_spending(
     params: &Parameters,
-    voucher_value: u64,
-    voucher_info: String,
+    public_attributes: Vec<Vec<u8>>,
     serial_number: Attribute,
     binding_number: Attribute,
     signature: &Signature,
@@ -191,10 +190,9 @@ pub fn prepare_credential_for_spending(
     )?;
 
     Ok(Credential::new(
-        PUBLIC_ATTRIBUTES + PRIVATE_ATTRIBUTES,
+        (public_attributes.len() + PRIVATE_ATTRIBUTES as usize) as u32,
         theta,
-        voucher_value.to_string(),
-        voucher_info,
+        public_attributes,
         signature,
     ))
 }

common/credentials/src/error.rs

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #[cfg(feature = "coconut")]
-use coconut_interface::{error::CoconutInterfaceError, CoconutError};
+use coconut_interface::CoconutError;
 use crypto::asymmetric::encryption::KeyRecoveryError;
 use validator_client::ValidatorClientError;
 
@@ -17,16 +17,18 @@ pub enum Error {
     NoValidatorsAvailable,
 
     #[cfg(feature = "coconut")]
-    #[error("Ran into a coconut error - {0}")]
+    #[error("Run into a coconut error - {0}")]
     CoconutError(#[from] CoconutError),
 
-    #[cfg(feature = "coconut")]
-    #[error("Ran into a coconut interface error - {0}")]
-    CoconutInterfaceError(#[from] CoconutInterfaceError),
-
-    #[error("Ran into a validator client error - {0}")]
+    #[error("Run into a validato client error - {0}")]
     ValidatorClientError(#[from] ValidatorClientError),
 
+    #[error("Not enough public attributes were specified")]
+    NotEnoughPublicAttributes,
+
+    #[error("Bandwidth is expected to be represented on 8 bytes")]
+    InvalidBandwidthSize,
+
     #[error("Bandwidth operation overflowed. {0}")]
     BandwidthOverflow(String),
 

common/crypto/dkg/Cargo.toml

@@ -1,41 +0,0 @@
-[package]
-name = "dkg"
-version = "0.1.0"
-edition = "2021"
-resolver = "2"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-bitvec = "1.0.0"
-
-# unfortunately until https://github.com/zkcrypto/bls12_381/issues/10 is resolved, we have to rely on the fork
-# as we need to be able to serialize Gt so that we could create the lookup table for baby-step-giant-step algorithm
-bls12_381 = { git = "https://github.com/jstuczyn/bls12_381", branch ="gt-serialisation", default-features = false, features = ["alloc", "pairings", "experimental", "zeroize"] }
-
-bs58 = "0.4"
-
-lazy_static = "1.4.0"
-rand = { version = "0.8.5", default-features = false}
-rand_chacha = "0.3"
-rand_core = "0.6.3"
-sha2 = "0.9"
-serde = "1.0"
-serde_derive = "1.0"
-thiserror = "1.0"
-zeroize = { version = "1.4", features = ["zeroize_derive"] }
-
-[dependencies.group]
-version = "0.11"
-default-features = false
-
-[dependencies.ff]
-version = "0.11"
-default-features = false
-
-[dev-dependencies]
-criterion = "0.3"
-
-[[bench]]
-name = "benchmarks"
-harness = false

common/crypto/dkg/benches/benchmarks.rs

@@ -1,541 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use bls12_381::{G1Projective, G2Affine, G2Prepared, Scalar};
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use dkg::bte::encryption::BabyStepGiantStepLookup;
-use dkg::bte::proof_chunking::ProofOfChunking;
-use dkg::bte::proof_discrete_log::ProofOfDiscreteLog;
-use dkg::bte::proof_sharing::ProofOfSecretSharing;
-use dkg::bte::{
-    decrypt_share, encrypt_shares, keygen, proof_chunking, proof_sharing, setup, DecryptionKey,
-    Epoch, PublicKey,
-};
-use dkg::interpolation::polynomial::Polynomial;
-use dkg::{Dealing, NodeIndex, Share};
-use ff::Field;
-use rand_core::{RngCore, SeedableRng};
-use std::collections::BTreeMap;
-
-pub fn precompute_default_bsgs_table(c: &mut Criterion) {
-    c.bench_function("bsgs default table", |b| {
-        b.iter(|| black_box(BabyStepGiantStepLookup::default()))
-    });
-}
-
-pub fn precomputing_g2_generator_for_miller_loop(c: &mut Criterion) {
-    let g2 = G2Affine::generator();
-    c.bench_function("precomputing G2Prepared", |b| {
-        b.iter(|| black_box(G2Prepared::from(g2)))
-    });
-}
-
-fn prepare_keys(
-    mut rng: impl RngCore,
-    nodes: usize,
-) -> (BTreeMap<NodeIndex, PublicKey>, Vec<DecryptionKey>) {
-    let params = setup();
-    let mut node_indices = (0..nodes).map(|_| rng.next_u64()).collect::<Vec<_>>();
-    node_indices.sort_unstable();
-
-    let mut receivers = BTreeMap::new();
-    let mut dks = Vec::new();
-    for index in &node_indices {
-        let (dk, pk) = keygen(&params, &mut rng);
-        receivers.insert(*index, *pk.public_key());
-        dks.push(dk)
-    }
-
-    (receivers, dks)
-}
-
-pub fn creating_dealing_for_3_parties(c: &mut Criterion) {
-    let dummy_seed = [42u8; 32];
-    let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-    let params = setup();
-    let threshold = 2;
-    let epoch = Epoch::new(2);
-
-    let (receivers, _) = prepare_keys(&mut rng, 3);
-
-    c.bench_function("creating single dealing for 3 parties (threshold 2)", |b| {
-        b.iter(|| {
-            black_box({
-                Dealing::create(
-                    &mut rng,
-                    &params,
-                    receivers.keys().next().copied().unwrap(),
-                    threshold,
-                    epoch,
-                    &receivers,
-                )
-            })
-        })
-    });
-}
-
-pub fn verifying_dealing_made_for_3_parties_and_recovering_share(c: &mut Criterion) {
-    let dummy_seed = [42u8; 32];
-    let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-    let params = setup();
-    let threshold = 2;
-    let epoch = Epoch::new(2);
-
-    let (receivers, mut dks) = prepare_keys(&mut rng, 3);
-    let (dealing, _) = Dealing::create(
-        &mut rng,
-        &params,
-        receivers.keys().next().copied().unwrap(),
-        threshold,
-        epoch,
-        &receivers,
-    );
-
-    let first_key = dks.get_mut(0).unwrap();
-    first_key.try_update_to(epoch, &params, &mut rng).unwrap();
-
-    c.bench_function(
-        "verifying single dealing made for 3 parties (threshold 2) and recovering share",
-        |b| {
-            b.iter(|| {
-                assert!(dealing
-                    .verify(&params, epoch, threshold, &receivers)
-                    .is_ok());
-                black_box(decrypt_share(first_key, 0, &dealing.ciphertexts, epoch, None).unwrap());
-            })
-        },
-    );
-}
-
-pub fn creating_dealing_for_20_parties(c: &mut Criterion) {
-    let dummy_seed = [42u8; 32];
-    let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-    let params = setup();
-    let threshold = 14;
-    let epoch = Epoch::new(2);
-
-    let (receivers, _) = prepare_keys(&mut rng, 20);
-
-    c.bench_function(
-        "creating single dealing for 20 parties (threshold 14)",
-        |b| {
-            b.iter(|| {
-                black_box({
-                    Dealing::create(
-                        &mut rng,
-                        &params,
-                        receivers.keys().next().copied().unwrap(),
-                        threshold,
-                        epoch,
-                        &receivers,
-                    )
-                })
-            })
-        },
-    );
-}
-
-pub fn verifying_dealing_made_for_20_parties_and_recovering_share(c: &mut Criterion) {
-    let dummy_seed = [42u8; 32];
-    let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-    let params = setup();
-    let threshold = 14;
-    let epoch = Epoch::new(2);
-
-    let (receivers, mut dks) = prepare_keys(&mut rng, 20);
-    let (dealing, _) = Dealing::create(
-        &mut rng,
-        &params,
-        receivers.keys().next().copied().unwrap(),
-        threshold,
-        epoch,
-        &receivers,
-    );
-
-    let first_key = dks.get_mut(0).unwrap();
-    first_key.try_update_to(epoch, &params, &mut rng).unwrap();
-
-    c.bench_function(
-        "verifying single dealing made for 20 parties (threshold 14) and recovering share",
-        |b| {
-            b.iter(|| {
-                assert!(dealing
-                    .verify(&params, epoch, threshold, &receivers)
-                    .is_ok());
-                black_box(decrypt_share(first_key, 0, &dealing.ciphertexts, epoch, None).unwrap());
-            })
-        },
-    );
-}
-
-pub fn creating_dealing_for_100_parties(c: &mut Criterion) {
-    let dummy_seed = [42u8; 32];
-    let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-    let params = setup();
-    let threshold = 67;
-    let epoch = Epoch::new(2);
-
-    let (receivers, _) = prepare_keys(&mut rng, 100);
-
-    c.bench_function(
-        "creating single dealing for 100 parties (threshold 67)",
-        |b| {
-            b.iter(|| {
-                black_box({
-                    Dealing::create(
-                        &mut rng,
-                        &params,
-                        receivers.keys().next().copied().unwrap(),
-                        threshold,
-                        epoch,
-                        &receivers,
-                    )
-                })
-            })
-        },
-    );
-}
-
-pub fn verifying_dealing_made_for_100_parties_and_recovering_share(c: &mut Criterion) {
-    let dummy_seed = [42u8; 32];
-    let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-    let params = setup();
-    let threshold = 67;
-    let epoch = Epoch::new(2);
-
-    let (receivers, mut dks) = prepare_keys(&mut rng, 100);
-    let (dealing, _) = Dealing::create(
-        &mut rng,
-        &params,
-        receivers.keys().next().copied().unwrap(),
-        threshold,
-        epoch,
-        &receivers,
-    );
-
-    let first_key = dks.get_mut(0).unwrap();
-    first_key.try_update_to(epoch, &params, &mut rng).unwrap();
-
-    c.bench_function(
-        "verifying single dealing made for 100 parties (threshold 67) and recovering share",
-        |b| {
-            b.iter(|| {
-                assert!(dealing
-                    .verify(&params, epoch, threshold, &receivers)
-                    .is_ok());
-                black_box(decrypt_share(first_key, 0, &dealing.ciphertexts, epoch, None).unwrap());
-            })
-        },
-    );
-}
-
-pub fn creating_proof_of_key_possession(c: &mut Criterion) {
-    let dummy_seed = [42u8; 32];
-    let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-
-    let g1 = G1Projective::generator();
-    let x = Scalar::random(&mut rng);
-    let y = g1 * x;
-
-    c.bench_function("creating proof of key possession", |b| {
-        b.iter(|| black_box(ProofOfDiscreteLog::construct(&mut rng, &y, &x)))
-    });
-}
-
-pub fn verifying_proof_of_key_possession(c: &mut Criterion) {
-    let dummy_seed = [42u8; 32];
-    let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-
-    let g1 = G1Projective::generator();
-    let x = Scalar::random(&mut rng);
-    let y = g1 * x;
-
-    let zk_proof = ProofOfDiscreteLog::construct(&mut rng, &y, &x);
-    c.bench_function("verifying proof of key possession", |b| {
-        b.iter(|| black_box(zk_proof.verify(&y)))
-    });
-}
-
-pub fn creating_proof_of_chunking_for_100_parties(c: &mut Criterion) {
-    let dummy_seed = [42u8; 32];
-    let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-    let params = setup();
-    let epoch = Epoch::new(2);
-
-    let (receivers, _) = prepare_keys(&mut rng, 100);
-
-    let polynomial = Polynomial::new_random(&mut rng, 67);
-    let shares = receivers
-        .keys()
-        .map(|&node_index| polynomial.evaluate_at(&Scalar::from(node_index)).into())
-        .collect::<Vec<_>>();
-
-    let remote_share_key_pairs = shares
-        .iter()
-        .zip(receivers.values())
-        .map(|(share, key)| (share, key))
-        .collect::<Vec<_>>();
-    let ordered_public_keys = receivers.values().copied().collect::<Vec<_>>();
-
-    let (ciphertexts, hazmat) = encrypt_shares(&remote_share_key_pairs, epoch, &params, &mut rng);
-
-    c.bench_function("creating proof of chunking for 100 parties", |b| {
-        b.iter(|| {
-            let chunking_instance =
-                proof_chunking::Instance::new(&ordered_public_keys, &ciphertexts);
-            black_box(
-                ProofOfChunking::construct(&mut rng, chunking_instance, hazmat.r(), &shares)
-                    .expect("failed to construct proof of chunking"),
-            )
-        })
-    });
-}
-
-pub fn verifying_proof_of_chunking_for_100_parties(c: &mut Criterion) {
-    let dummy_seed = [42u8; 32];
-    let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-    let params = setup();
-    let epoch = Epoch::new(2);
-
-    let (receivers, _) = prepare_keys(&mut rng, 100);
-
-    let polynomial = Polynomial::new_random(&mut rng, 67);
-    let shares = receivers
-        .keys()
-        .map(|&node_index| polynomial.evaluate_at(&Scalar::from(node_index)).into())
-        .collect::<Vec<_>>();
-
-    let remote_share_key_pairs = shares
-        .iter()
-        .zip(receivers.values())
-        .map(|(share, key)| (share, key))
-        .collect::<Vec<_>>();
-    let ordered_public_keys = receivers.values().copied().collect::<Vec<_>>();
-
-    let (ciphertexts, hazmat) = encrypt_shares(&remote_share_key_pairs, epoch, &params, &mut rng);
-
-    let chunking_instance = proof_chunking::Instance::new(&ordered_public_keys, &ciphertexts);
-    let proof_of_chunking =
-        ProofOfChunking::construct(&mut rng, chunking_instance, hazmat.r(), &shares)
-            .expect("failed to construct proof of chunking");
-
-    c.bench_function("verifying proof of chunking for 100 parties", |b| {
-        b.iter(|| {
-            let chunking_instance =
-                proof_chunking::Instance::new(&ordered_public_keys, &ciphertexts);
-            black_box(proof_of_chunking.verify(chunking_instance))
-        })
-    });
-}
-
-pub fn creating_proof_of_secret_sharing_for_100_parties(c: &mut Criterion) {
-    let dummy_seed = [42u8; 32];
-    let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-    let params = setup();
-    let epoch = Epoch::new(2);
-
-    let (receivers, _) = prepare_keys(&mut rng, 100);
-
-    let polynomial = Polynomial::new_random(&mut rng, 67);
-    let shares = receivers
-        .keys()
-        .map(|&node_index| polynomial.evaluate_at(&Scalar::from(node_index)).into())
-        .collect::<Vec<_>>();
-
-    let remote_share_key_pairs = shares
-        .iter()
-        .zip(receivers.values())
-        .map(|(share, key)| (share, key))
-        .collect::<Vec<_>>();
-
-    let (ciphertexts, hazmat) = encrypt_shares(&remote_share_key_pairs, epoch, &params, &mut rng);
-
-    let combined_ciphertexts = ciphertexts.combine_ciphertexts();
-    let combined_r = hazmat.combine_rs();
-    let combined_rr = ciphertexts.combine_rs();
-    let public_coefficients = polynomial.public_coefficients();
-
-    c.bench_function("creating proof of secret sharing for 100 parties", |b| {
-        b.iter(|| {
-            let sharing_instance = proof_sharing::Instance::new(
-                &receivers,
-                &public_coefficients,
-                &combined_rr,
-                &combined_ciphertexts,
-            );
-            black_box(
-                ProofOfSecretSharing::construct(&mut rng, sharing_instance, &combined_r, &shares)
-                    .expect("failed to construct proof of secret sharing"),
-            )
-        })
-    });
-}
-
-pub fn verifying_proof_of_secret_sharing_for_100_parties(c: &mut Criterion) {
-    let dummy_seed = [42u8; 32];
-    let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-    let params = setup();
-    let epoch = Epoch::new(2);
-
-    let (receivers, _) = prepare_keys(&mut rng, 100);
-
-    let polynomial = Polynomial::new_random(&mut rng, 67);
-    let shares = receivers
-        .keys()
-        .map(|&node_index| polynomial.evaluate_at(&Scalar::from(node_index)).into())
-        .collect::<Vec<_>>();
-
-    let remote_share_key_pairs = shares
-        .iter()
-        .zip(receivers.values())
-        .map(|(share, key)| (share, key))
-        .collect::<Vec<_>>();
-
-    let (ciphertexts, hazmat) = encrypt_shares(&remote_share_key_pairs, epoch, &params, &mut rng);
-
-    let combined_ciphertexts = ciphertexts.combine_ciphertexts();
-    let combined_r = hazmat.combine_rs();
-    let combined_rr = ciphertexts.combine_rs();
-    let public_coefficients = polynomial.public_coefficients();
-    let sharing_instance = proof_sharing::Instance::new(
-        &receivers,
-        &public_coefficients,
-        &combined_rr,
-        &combined_ciphertexts,
-    );
-    let proof_of_secret_sharing =
-        ProofOfSecretSharing::construct(&mut rng, sharing_instance, &combined_r, &shares)
-            .expect("failed to construct proof of secret sharing");
-
-    c.bench_function("verifying proof of secret sharing for 100 parties", |b| {
-        b.iter(|| {
-            let sharing_instance = proof_sharing::Instance::new(
-                &receivers,
-                &public_coefficients,
-                &combined_rr,
-                &combined_ciphertexts,
-            );
-            black_box(proof_of_secret_sharing.verify(sharing_instance))
-        })
-    });
-}
-
-pub fn single_share_encryption(c: &mut Criterion) {
-    let dummy_seed = [42u8; 32];
-    let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-    let params = setup();
-    let epoch = Epoch::new(2);
-    let (_, pk) = keygen(&params, &mut rng);
-
-    let polynomial = Polynomial::new_random(&mut rng, 3);
-    let share: Share = polynomial.evaluate_at(&Scalar::from(42)).into();
-
-    c.bench_function("single share encryption", |b| {
-        b.iter(|| {
-            black_box(encrypt_shares(
-                &[(&share, pk.public_key())],
-                epoch,
-                &params,
-                &mut rng,
-            ))
-        })
-    });
-}
-
-pub fn share_encryption_100(c: &mut Criterion) {
-    let dummy_seed = [42u8; 32];
-    let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-    let params = setup();
-    let epoch = Epoch::new(2);
-
-    let (receivers, _) = prepare_keys(&mut rng, 100);
-    let polynomial = Polynomial::new_random(&mut rng, 3);
-    let shares = receivers
-        .keys()
-        .map(|&node_index| polynomial.evaluate_at(&Scalar::from(node_index)).into())
-        .collect::<Vec<_>>();
-
-    let remote_share_key_pairs = shares
-        .iter()
-        .zip(receivers.values())
-        .map(|(share, key)| (share, key))
-        .collect::<Vec<_>>();
-
-    c.bench_function("100 shares encryption", |b| {
-        b.iter(|| {
-            black_box(encrypt_shares(
-                &remote_share_key_pairs,
-                epoch,
-                &params,
-                &mut rng,
-            ))
-        })
-    });
-}
-
-pub fn share_decryption(c: &mut Criterion) {
-    let dummy_seed = [42u8; 32];
-    let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-    let params = setup();
-    let epoch = Epoch::new(2);
-    let (mut dk, pk) = keygen(&params, &mut rng);
-
-    let polynomial = Polynomial::new_random(&mut rng, 3);
-    let share: Share = polynomial.evaluate_at(&Scalar::from(42)).into();
-    let (ciphertexts, _) = encrypt_shares(&[(&share, pk.public_key())], epoch, &params, &mut rng);
-    dk.try_update_to(epoch, &params, &mut rng).unwrap();
-
-    c.bench_function("single share decryption", |b| {
-        b.iter(|| black_box(decrypt_share(&dk, 0, &ciphertexts, epoch, None)))
-    });
-}
-
-criterion_group!(
-    utils,
-    precompute_default_bsgs_table,
-    precomputing_g2_generator_for_miller_loop,
-);
-
-criterion_group!(
-    dealings_creation,
-    creating_dealing_for_3_parties,
-    creating_dealing_for_20_parties,
-    creating_dealing_for_100_parties,
-);
-
-// note: in our setting each party will have to create at least 4 dealings (one per attribute in credential)
-// and verify 99 * 4 of them (4 from each other dealer)
-criterion_group!(
-    dealings_verification,
-    verifying_dealing_made_for_3_parties_and_recovering_share,
-    verifying_dealing_made_for_20_parties_and_recovering_share,
-    verifying_dealing_made_for_100_parties_and_recovering_share,
-);
-
-criterion_group!(
-    proofs_of_knowledge,
-    creating_proof_of_key_possession,
-    verifying_proof_of_key_possession,
-    creating_proof_of_chunking_for_100_parties,
-    verifying_proof_of_chunking_for_100_parties,
-    creating_proof_of_secret_sharing_for_100_parties,
-    verifying_proof_of_secret_sharing_for_100_parties
-);
-
-criterion_group!(
-    encryption,
-    single_share_encryption,
-    share_encryption_100,
-    share_decryption,
-);
-
-criterion_main!(
-    utils,
-    dealings_creation,
-    dealings_verification,
-    proofs_of_knowledge,
-    encryption
-);
-
-// TODO: benchmark using affine vs projective representation throughout the crate
-// (when conversion / serialization / computation is involved)

common/crypto/dkg/src/bte/encryption.rs

@@ -1,772 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::bte::keys::{DecryptionKey, PublicKey};
-use crate::bte::{Epoch, Params, CHUNK_SIZE, G2_GENERATOR_PREPARED, NUM_CHUNKS, PAIRING_BASE};
-use crate::error::DkgError;
-use crate::utils::{combine_g1_chunks, combine_scalar_chunks, deserialize_g1, deserialize_g2};
-use crate::{Chunk, ChunkedShare, Share};
-use bls12_381::{G1Affine, G1Projective, G2Prepared, G2Projective, Gt, Scalar};
-use ff::Field;
-use group::{Curve, Group, GroupEncoding};
-use rand_core::RngCore;
-use std::collections::HashMap;
-use std::ops::Neg;
-use zeroize::Zeroize;
-
-#[derive(Debug)]
-#[cfg_attr(test, derive(Clone, PartialEq))]
-pub struct Ciphertexts {
-    pub rr: [G1Projective; NUM_CHUNKS],
-    pub ss: [G1Projective; NUM_CHUNKS],
-    pub zz: [G2Projective; NUM_CHUNKS],
-    pub ciphertext_chunks: Vec<[G1Projective; NUM_CHUNKS]>,
-}
-
-impl Ciphertexts {
-    pub fn verify_integrity(&self, params: &Params, epoch: Epoch) -> bool {
-        // if this checks fails it means the ciphertext is undefined as values
-        // in `r`, `s` and `z` are meaningless since technically this ciphertext
-        // has been created for 0 parties
-        if self.ciphertext_chunks.is_empty() {
-            return false;
-        }
-
-        let g1_neg = G1Affine::generator().neg();
-        let f = epoch
-            .as_extended_tau(&self.rr, &self.ss, &self.ciphertext_chunks)
-            .evaluate_f(params);
-
-        // we have to use `f` in up to `NUM_CHUNKS` pairings (if everything is valid),
-        // so perform some precomputation on it
-        let f_prepared = G2Prepared::from(f.to_affine());
-
-        // for each triple (R_i, S_i, Z_i) check whether e(g1, Z_i) == e(R_j, f) • e(S_i, h),
-        // which is equivalent to checking whether e(R_j, f) • e(S_i, h) • e(g1, Z_i)^-1 == id
-        // and due to bilinear property whether e(R_j, f) • e(S_i, h) • e(g1^-1, Z_i) == id
-        for i in 0..self.rr.len() {
-            let miller = bls12_381::multi_miller_loop(&[
-                (&self.rr[i].to_affine(), &f_prepared),
-                (&self.ss[i].to_affine(), &params._h_prepared),
-                (&g1_neg, &G2Prepared::from(self.zz[i].to_affine())),
-            ]);
-            let res = miller.final_exponentiation();
-            if !bool::from(res.is_identity()) {
-                return false;
-            }
-        }
-
-        true
-    }
-
-    pub fn combine_rs(&self) -> G1Projective {
-        combine_g1_chunks(&self.rr)
-    }
-
-    // required for the purposes of the proof of secret sharing
-    pub fn combine_ciphertexts(&self) -> Vec<G1Projective> {
-        self.ciphertext_chunks
-            .iter()
-            .map(|share_ciphertext| combine_g1_chunks(share_ciphertext))
-            .collect()
-    }
-
-    pub(crate) fn to_bytes(&self) -> Vec<u8> {
-        let num_receivers = self.ciphertext_chunks.len();
-
-        let mut bytes = Vec::with_capacity(NUM_CHUNKS * ((num_receivers + 2) * 48 + 96) + 4);
-        for r_i in &self.rr {
-            bytes.extend_from_slice(r_i.to_bytes().as_ref())
-        }
-        for s_i in &self.ss {
-            bytes.extend_from_slice(s_i.to_bytes().as_ref())
-        }
-        for z_i in &self.zz {
-            bytes.extend_from_slice(z_i.to_bytes().as_ref())
-        }
-
-        bytes.extend_from_slice(&(num_receivers as u32).to_be_bytes());
-        for c_i in &self.ciphertext_chunks {
-            for c_ij in c_i {
-                bytes.extend_from_slice(c_ij.to_bytes().as_ref())
-            }
-        }
-
-        bytes
-    }
-
-    pub(crate) fn try_from_bytes(bytes: &[u8]) -> Result<Self, DkgError> {
-        // at the very minimum we must have enough bytes for a single receiver
-        if bytes.len() < NUM_CHUNKS * (3 * 48 + 96) + 4 {
-            return Err(DkgError::new_deserialization_failure(
-                "Ciphertexts",
-                "insufficient number of bytes provided",
-            ));
-        }
-
-        let mut rr = Vec::with_capacity(NUM_CHUNKS);
-        let mut ss = Vec::with_capacity(NUM_CHUNKS);
-        let mut zz = Vec::with_capacity(NUM_CHUNKS);
-
-        let mut i = 0;
-        for _ in 0..NUM_CHUNKS {
-            rr.push(deserialize_g1(&bytes[i..i + 48]).ok_or_else(|| {
-                DkgError::new_deserialization_failure("Ciphertexts.r", "invalid curve point")
-            })?);
-            i += 48;
-        }
-        for _ in 0..NUM_CHUNKS {
-            ss.push(deserialize_g1(&bytes[i..i + 48]).ok_or_else(|| {
-                DkgError::new_deserialization_failure("Ciphertexts.s", "invalid curve point")
-            })?);
-            i += 48;
-        }
-        for _ in 0..NUM_CHUNKS {
-            zz.push(deserialize_g2(&bytes[i..i + 96]).ok_or_else(|| {
-                DkgError::new_deserialization_failure("Ciphertexts.z", "invalid curve point")
-            })?);
-            i += 96;
-        }
-
-        let num_receivers = u32::from_be_bytes(bytes[i..i + 4].try_into().unwrap()) as usize;
-        i += 4;
-
-        if bytes[i..].len() != num_receivers * NUM_CHUNKS * 48 {
-            return Err(DkgError::new_deserialization_failure(
-                "Ciphertexts",
-                "invalid number of bytes provided",
-            ));
-        }
-
-        let mut ciphertext_chunks = Vec::with_capacity(num_receivers);
-
-        for _ in 0..num_receivers {
-            let mut ci = Vec::with_capacity(NUM_CHUNKS);
-            for _ in 0..NUM_CHUNKS {
-                ci.push(deserialize_g1(&bytes[i..i + 48]).ok_or_else(|| {
-                    DkgError::new_deserialization_failure(
-                        "Ciphertexts.ciphertext_chunks",
-                        "invalid curve point",
-                    )
-                })?);
-                i += 48;
-            }
-
-            // this unwrap is fine as we have exactly NUM_CHUNKS elements in each vector
-            ciphertext_chunks.push(ci.try_into().unwrap())
-        }
-
-        // and the same is true here, the unwraps are fine as we have exactly NUM_CHUNKS elements in each as required
-        Ok(Ciphertexts {
-            rr: rr.try_into().unwrap(),
-            ss: ss.try_into().unwrap(),
-            zz: zz.try_into().unwrap(),
-            ciphertext_chunks,
-        })
-    }
-}
-
-#[derive(Zeroize)]
-#[zeroize(drop)]
-/// Randomness generated during ciphertext generation that is required for proofs of knowledge.
-/// It must be handled with extreme care as its misuse might help malicious parties to recover
-/// the underlying plaintext.
-pub struct HazmatRandomness {
-    r: [Scalar; NUM_CHUNKS],
-    s: [Scalar; NUM_CHUNKS],
-}
-
-impl HazmatRandomness {
-    pub fn r(&self) -> &[Scalar; NUM_CHUNKS] {
-        &self.r
-    }
-
-    pub fn s(&self) -> &[Scalar; NUM_CHUNKS] {
-        &self.s
-    }
-
-    pub fn combine_rs(&self) -> Scalar {
-        combine_scalar_chunks(&self.r)
-    }
-}
-
-pub fn encrypt_shares(
-    shares: &[(&Share, &PublicKey)],
-    epoch: Epoch,
-    params: &Params,
-    mut rng: impl RngCore,
-) -> (Ciphertexts, HazmatRandomness) {
-    let g1 = G1Projective::generator();
-
-    let mut rand_rs = Vec::with_capacity(NUM_CHUNKS);
-    let mut rand_ss = Vec::with_capacity(NUM_CHUNKS);
-    let mut rr = Vec::with_capacity(NUM_CHUNKS);
-    let mut ss = Vec::with_capacity(NUM_CHUNKS);
-
-    // generate relevant re-usable pseudorandom data
-    for _ in 0..NUM_CHUNKS {
-        let rand_r = Scalar::random(&mut rng);
-        let rand_s = Scalar::random(&mut rng);
-
-        // g1^r
-        let rr_i = g1 * rand_r;
-        // g1^s
-        let ss_i = g1 * rand_s;
-
-        rand_rs.push(rand_r);
-        rand_ss.push(rand_s);
-
-        rr.push(rr_i);
-        ss.push(ss_i);
-    }
-
-    // produce per-chunk ciphertexts
-    let mut cc = Vec::with_capacity(shares.len());
-
-    for (share, pk) in shares {
-        let m = share.to_chunks();
-
-        let mut ci = Vec::with_capacity(NUM_CHUNKS);
-
-        for (j, chunk) in m.chunks.iter().enumerate() {
-            // can't really have a more efficient implementation until https://github.com/zkcrypto/bls12_381/pull/70 is merged...
-            let c = pk.0 * rand_rs[j] + g1 * Scalar::from(*chunk as u64);
-            ci.push(c)
-        }
-
-        // the conversion must succeed since we must have EXACTLY `NUM_CHUNKS` elements
-        cc.push(ci.try_into().unwrap())
-    }
-
-    // convert into arrays, note that the unwraps are fine as we have exactly `NUM_CHUNKS` elements in each vector
-    let rr = rr.try_into().unwrap();
-    let ss = ss.try_into().unwrap();
-
-    let f = epoch.as_extended_tau(&rr, &ss, &cc).evaluate_f(params);
-
-    let mut zz = Vec::with_capacity(NUM_CHUNKS);
-    for i in 0..NUM_CHUNKS {
-        zz.push(f * rand_rs[i] + params.h * rand_ss[i]);
-    }
-
-    // the conversions here must also succeed since the other vecs also have `NUM_CHUNKS` elements
-    (
-        Ciphertexts {
-            rr,
-            ss,
-            zz: zz.try_into().unwrap(),
-            ciphertext_chunks: cc,
-        },
-        HazmatRandomness {
-            r: rand_rs.try_into().unwrap(),
-            s: rand_ss.try_into().unwrap(),
-        },
-    )
-}
-
-pub fn decrypt_share(
-    dk: &DecryptionKey,
-    // in the case of multiple receivers, specifies which index of ciphertext chunks should be used
-    i: usize,
-    ciphertext: &Ciphertexts,
-    epoch: Epoch,
-    lookup_table: Option<&BabyStepGiantStepLookup>,
-) -> Result<Share, DkgError> {
-    let mut plaintext = ChunkedShare::default();
-
-    let decryption_node = dk.try_get_compatible_node(epoch)?;
-    let extended_tau = epoch.as_extended_tau(
-        &ciphertext.rr,
-        &ciphertext.ss,
-        &ciphertext.ciphertext_chunks,
-    );
-
-    if i >= ciphertext.ciphertext_chunks.len() {
-        return Err(DkgError::UnavailableCiphertext(i));
-    }
-
-    let height = decryption_node.tau.height();
-    let b_neg = decryption_node
-        .ds
-        .iter()
-        .chain(decryption_node.dh.iter())
-        .zip(extended_tau.0.iter().by_vals().skip(height))
-        .filter(|(_, i)| *i)
-        .map(|(d_i, _)| d_i)
-        .fold(decryption_node.b, |acc, d_i| acc + d_i)
-        .neg()
-        .to_affine();
-
-    let e_neg = decryption_node.e.neg().to_affine();
-
-    for j in 0..NUM_CHUNKS {
-        let rr_j = &ciphertext.rr[j];
-        let ss_j = &ciphertext.ss[j];
-        let zz_j = ciphertext.zz[j].to_affine();
-        let cc_ij = &ciphertext.ciphertext_chunks[i][j];
-
-        let miller = bls12_381::multi_miller_loop(&[
-            (&cc_ij.to_affine(), &G2_GENERATOR_PREPARED),
-            (&rr_j.to_affine(), &G2Prepared::from(b_neg)),
-            (&decryption_node.a.to_affine(), &G2Prepared::from(zz_j)),
-            (&ss_j.to_affine(), &G2Prepared::from(e_neg)),
-        ]);
-        let m = miller.final_exponentiation();
-
-        plaintext.chunks[j] = baby_step_giant_step(&m, &PAIRING_BASE, lookup_table)?;
-    }
-
-    plaintext.try_into()
-}
-
-pub struct BabyStepGiantStepLookup {
-    base: Gt,
-    m: Chunk,
-    lookup: HashMap<[u8; 576], Chunk>,
-}
-
-impl BabyStepGiantStepLookup {
-    pub fn precompute(base: &Gt) -> Self {
-        let mut lookup = HashMap::new();
-        let mut g = Gt::identity();
-
-        // 1. m ← Ceiling(√n)
-        let m = (CHUNK_SIZE as f32).sqrt().ceil() as Chunk;
-
-        // 2. For all j where 0 ≤ j < m:
-        for j in 0..m {
-            // Compute α^j and store the pair (j, α^j) in a table.
-            lookup.insert(g.to_uncompressed(), j);
-            g += base;
-        }
-
-        BabyStepGiantStepLookup {
-            base: *base,
-            m,
-            lookup,
-        }
-    }
-
-    pub fn try_solve(&self, target: &Gt) -> Result<Chunk, DkgError> {
-        // 3. Compute α^{−m}
-        let m_neg = Scalar::from(self.m as u64).neg();
-        let alpha_m = self.base * m_neg;
-
-        // 4. γ ← β. (set γ = β)
-        let mut gamma = *target;
-
-        // 5. For all i where 0 ≤ i < m:
-        for i in 0..self.m {
-            // 1. Check to see if γ is the second component (αj) of any pair in the table.
-            if let Some(j) = self.lookup.get(&gamma.to_uncompressed()) {
-                // 2. If so, return im + j.
-                return Ok(i * self.m + j);
-            } else {
-                // 3. If not, γ ← γ • α^{−m}.
-                gamma += alpha_m;
-            }
-        }
-
-        Err(DkgError::UnsolvableDiscreteLog)
-    }
-}
-
-impl Default for BabyStepGiantStepLookup {
-    fn default() -> Self {
-        BabyStepGiantStepLookup::precompute(&PAIRING_BASE)
-    }
-}
-
-/// Attempts to solve the discrete log problem g^m, where g is in the Gt group and
-/// m should be within the [0, CHUNK_MAX] range.
-///
-/// The implementation follows the following algorithm: https://en.wikipedia.org/wiki/Baby-step_giant-step#The_algorithm
-///
-/// # Arguments
-///
-/// * `target`: the result of the exponentiation, M in M = g^m,
-/// * `base`: the base used for exponentiation, g in M = g^m
-/// * `lookup_table`: precomputed table containing (j, α^j) pairs
-pub fn baby_step_giant_step(
-    target: &Gt,
-    base: &Gt,
-    lookup_table: Option<&BabyStepGiantStepLookup>,
-) -> Result<Chunk, DkgError> {
-    if let Some(lookup_table) = lookup_table {
-        // compute expected m to make sure the provided lookup is valid
-        let m = (CHUNK_SIZE as f32).sqrt().ceil() as Chunk;
-
-        if &lookup_table.base != base || lookup_table.lookup.len() != m as usize {
-            return Err(DkgError::MismatchedLookupTable);
-        }
-
-        lookup_table.try_solve(target)
-    } else {
-        BabyStepGiantStepLookup::precompute(base).try_solve(target)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::bte::{keygen, setup, DEFAULT_BSGS_TABLE};
-    use rand_core::SeedableRng;
-
-    fn verify_hazmat_rand(ciphertext: &Ciphertexts, randomness: &HazmatRandomness) {
-        let g1 = G1Projective::generator();
-
-        for i in 0..ciphertext.rr.len() {
-            assert_eq!(ciphertext.rr[i], g1 * randomness.r[i]);
-            assert_eq!(ciphertext.ss[i], g1 * randomness.s[i]);
-        }
-    }
-
-    #[test]
-    fn baby_giant_100_without_table() {
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-
-        for i in 0u64..100 {
-            let base = Gt::random(&mut rng);
-            let x = (rng.next_u64() + i) % CHUNK_SIZE as u64;
-            let target = base * Scalar::from(x);
-
-            assert_eq!(
-                baby_step_giant_step(&target, &base, None).unwrap(),
-                x as Chunk
-            );
-        }
-    }
-
-    #[test]
-    fn baby_giant_100_with_table() {
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-        let base = Gt::random(&mut rng);
-        let lookup_table = BabyStepGiantStepLookup::precompute(&base);
-        let table = Some(&lookup_table);
-
-        for i in 0u64..100 {
-            let x = (rng.next_u64() + i) % CHUNK_SIZE as u64;
-            let target = base * Scalar::from(x);
-
-            assert_eq!(
-                baby_step_giant_step(&target, &base, table).unwrap(),
-                x as Chunk
-            );
-        }
-    }
-
-    #[test]
-    fn share_decryption_20() {
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-        let params = setup();
-
-        let (decryption_key1, public_key1) = keygen(&params, &mut rng);
-        let (decryption_key2, public_key2) = keygen(&params, &mut rng);
-        let epoch = Epoch::new(0);
-
-        let lookup_table = &DEFAULT_BSGS_TABLE;
-
-        for _ in 0..10 {
-            let m1 = Share::random(&mut rng);
-            let m2 = Share::random(&mut rng);
-            let shares = &[(&m1, &public_key1.key), (&m2, &public_key2.key)];
-
-            let (ciphertext, hazmat) = encrypt_shares(shares, epoch, &params, &mut rng);
-            verify_hazmat_rand(&ciphertext, &hazmat);
-
-            let recovered1 =
-                decrypt_share(&decryption_key1, 0, &ciphertext, epoch, Some(lookup_table)).unwrap();
-            let recovered2 =
-                decrypt_share(&decryption_key2, 1, &ciphertext, epoch, Some(lookup_table)).unwrap();
-            assert_eq!(m1, recovered1);
-            assert_eq!(m2, recovered2);
-        }
-    }
-
-    #[test]
-    fn share_encryption_under_nonzero_epoch() {
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-        let params = setup();
-
-        let (mut decryption_key1, public_key1) = keygen(&params, &mut rng);
-        let (mut decryption_key2, public_key2) = keygen(&params, &mut rng);
-        let epoch = Epoch::new(12345);
-        decryption_key1
-            .try_update_to(epoch, &params, &mut rng)
-            .unwrap();
-        decryption_key2
-            .try_update_to(epoch, &params, &mut rng)
-            .unwrap();
-
-        let lookup_table = &DEFAULT_BSGS_TABLE;
-
-        for _ in 0..10 {
-            let m1 = Share::random(&mut rng);
-            let m2 = Share::random(&mut rng);
-            let shares = &[(&m1, &public_key1.key), (&m2, &public_key2.key)];
-
-            let (ciphertext, hazmat) = encrypt_shares(shares, epoch, &params, &mut rng);
-            verify_hazmat_rand(&ciphertext, &hazmat);
-
-            let recovered1 =
-                decrypt_share(&decryption_key1, 0, &ciphertext, epoch, Some(lookup_table)).unwrap();
-            let recovered2 =
-                decrypt_share(&decryption_key2, 1, &ciphertext, epoch, Some(lookup_table)).unwrap();
-            assert_eq!(m1, recovered1);
-            assert_eq!(m2, recovered2);
-        }
-    }
-
-    #[test]
-    fn decryption_with_root_key() {
-        let dummy_seed = [42u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-        let params = setup();
-
-        let (root_key, public_key) = keygen(&params, &mut rng);
-
-        let share = Share::random(&mut rng);
-
-        let epoch0 = Epoch::new(0);
-        let epoch42 = Epoch::new(42);
-        let epoch_big = Epoch::new(3292547435);
-
-        let (ciphertext1, hazmat1) =
-            encrypt_shares(&[(&share, &public_key.key)], epoch0, &params, &mut rng);
-        verify_hazmat_rand(&ciphertext1, &hazmat1);
-
-        let (ciphertext2, hazmat2) =
-            encrypt_shares(&[(&share, &public_key.key)], epoch42, &params, &mut rng);
-        verify_hazmat_rand(&ciphertext2, &hazmat2);
-
-        let (ciphertext3, hazmat3) =
-            encrypt_shares(&[(&share, &public_key.key)], epoch_big, &params, &mut rng);
-        verify_hazmat_rand(&ciphertext3, &hazmat3);
-
-        let recovered1 = decrypt_share(&root_key, 0, &ciphertext1, epoch0, None).unwrap();
-        let recovered2 = decrypt_share(&root_key, 0, &ciphertext2, epoch42, None).unwrap();
-        let recovered3 = decrypt_share(&root_key, 0, &ciphertext3, epoch_big, None).unwrap();
-
-        assert_eq!(share, recovered1);
-        assert_eq!(share, recovered2);
-        assert_eq!(share, recovered3);
-    }
-
-    #[test]
-    fn update_and_decrypt_10() {
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-        let params = setup();
-
-        let (mut decryption_key, public_key) = keygen(&params, &mut rng);
-
-        for epoch_value in 0..10 {
-            let epoch = Epoch::new(epoch_value);
-            let share = Share::random(&mut rng);
-            decryption_key
-                .try_update_to(epoch, &params, &mut rng)
-                .unwrap();
-
-            let (ciphertext, hazmat) =
-                encrypt_shares(&[(&share, &public_key.key)], epoch, &params, &mut rng);
-            verify_hazmat_rand(&ciphertext, &hazmat);
-
-            let recovered = decrypt_share(&decryption_key, 0, &ciphertext, epoch, None).unwrap();
-            assert_eq!(share, recovered);
-        }
-    }
-
-    #[test]
-    fn reblinding_node_doesnt_affect_decryption() {
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-        let params = setup();
-
-        let (mut decryption_key, public_key) = keygen(&params, &mut rng);
-
-        let epoch = Epoch::new(12345);
-        decryption_key
-            .try_update_to(epoch, &params, &mut rng)
-            .unwrap();
-        for node in decryption_key.nodes.iter_mut() {
-            node.reblind(&params, &mut rng);
-        }
-        let share = Share::random(&mut rng);
-
-        let (ciphertext, hazmat) =
-            encrypt_shares(&[(&share, &public_key.key)], epoch, &params, &mut rng);
-        verify_hazmat_rand(&ciphertext, &hazmat);
-
-        let recovered = decrypt_share(&decryption_key, 0, &ciphertext, epoch, None).unwrap();
-        assert_eq!(share, recovered);
-
-        // attempt to update the key again so we have to derive fresh nodes using previous reblinded results
-        let epoch2 = Epoch::new(67890);
-        decryption_key
-            .try_update_to(epoch2, &params, &mut rng)
-            .unwrap();
-        for node in decryption_key.nodes.iter_mut() {
-            node.reblind(&params, &mut rng);
-        }
-        let share2 = Share::random(&mut rng);
-
-        let (ciphertext, hazmat) =
-            encrypt_shares(&[(&share2, &public_key.key)], epoch2, &params, &mut rng);
-        verify_hazmat_rand(&ciphertext, &hazmat);
-
-        let recovered = decrypt_share(&decryption_key, 0, &ciphertext, epoch2, None).unwrap();
-        assert_eq!(share2, recovered);
-    }
-
-    #[test]
-    fn ciphertext_integrity_check_passes_for_valid_data() {
-        let params = setup();
-
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-
-        let (mut dk, public_key) = keygen(&params, &mut rng);
-        let epoch = Epoch::new(1);
-
-        dk.try_update_to(epoch, &params, &mut rng).unwrap();
-        let share = Share::random(&mut rng);
-        let (ciphertext, _) =
-            encrypt_shares(&[(&share, &public_key.key)], epoch, &params, &mut rng);
-        assert!(ciphertext.verify_integrity(&params, epoch))
-    }
-
-    #[test]
-    fn ciphertext_integrity_check_passes_fails_for_malformed_data() {
-        let params = setup();
-
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-
-        let (mut dk, public_key) = keygen(&params, &mut rng);
-        let epoch = Epoch::new(1);
-
-        dk.try_update_to(epoch, &params, &mut rng).unwrap();
-        let share = Share::random(&mut rng);
-        let (ciphertext, _) =
-            encrypt_shares(&[(&share, &public_key.key)], epoch, &params, &mut rng);
-
-        let mut bad_cipher1 = ciphertext.clone();
-        bad_cipher1.rr[4] = G1Projective::generator();
-        assert!(!bad_cipher1.verify_integrity(&params, epoch));
-
-        let mut bad_cipher2 = ciphertext.clone();
-        bad_cipher2.ss[4] = G1Projective::generator();
-        assert!(!bad_cipher2.verify_integrity(&params, epoch));
-
-        let mut bad_cipher3 = ciphertext;
-        bad_cipher3.zz[4] = G2Projective::generator();
-        assert!(!bad_cipher3.verify_integrity(&params, epoch));
-    }
-
-    #[test]
-    fn ciphertext_integrity_check_passes_fails_for_wrong_epoch() {
-        let params = setup();
-
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-
-        let (mut dk, public_key) = keygen(&params, &mut rng);
-        let epoch = Epoch::new(1);
-
-        dk.try_update_to(epoch, &params, &mut rng).unwrap();
-        let share = Share::random(&mut rng);
-        let (ciphertext, _) =
-            encrypt_shares(&[(&share, &public_key.key)], epoch, &params, &mut rng);
-
-        let another_epoch = Epoch::new(2);
-        assert!(!ciphertext.verify_integrity(&params, another_epoch))
-    }
-
-    #[test]
-    fn ciphertext_combining() {
-        let params = setup();
-
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-
-        let nodes = 3;
-
-        let mut shares = Vec::new();
-        let mut public_keys = Vec::new();
-        for _ in 0..nodes {
-            shares.push(Share::random(&mut rng));
-            let (_, pk) = keygen(&params, &mut rng);
-            public_keys.push(*pk.public_key());
-        }
-
-        let refs = shares.iter().zip(public_keys.iter()).collect::<Vec<_>>();
-        let (ciphertext, hazmat) = encrypt_shares(&refs, Epoch::new(42), &params, &mut rng);
-
-        let combined_r = combine_scalar_chunks(hazmat.r());
-        let combined_rr = ciphertext.combine_rs();
-        let combined_ciphertexts = ciphertext.combine_ciphertexts();
-
-        let g1 = G1Projective::generator();
-        for i in 0..nodes {
-            let expected = public_keys[i].0 * combined_r + g1 * shares[i].0;
-            assert_eq!(expected, combined_ciphertexts[i]);
-            assert_eq!(combined_rr, g1 * combined_r);
-        }
-    }
-
-    #[test]
-    fn ciphertexts_roundtrip() {
-        fn random_ciphertexts(mut rng: impl RngCore, num_receivers: usize) -> Ciphertexts {
-            Ciphertexts {
-                rr: (0..NUM_CHUNKS)
-                    .map(|_| G1Projective::random(&mut rng))
-                    .collect::<Vec<_>>()
-                    .try_into()
-                    .unwrap(),
-                ss: (0..NUM_CHUNKS)
-                    .map(|_| G1Projective::random(&mut rng))
-                    .collect::<Vec<_>>()
-                    .try_into()
-                    .unwrap(),
-                zz: (0..NUM_CHUNKS)
-                    .map(|_| G2Projective::random(&mut rng))
-                    .collect::<Vec<_>>()
-                    .try_into()
-                    .unwrap(),
-                ciphertext_chunks: (0..num_receivers)
-                    .map(|_| {
-                        (0..NUM_CHUNKS)
-                            .map(|_| G1Projective::random(&mut rng))
-                            .collect::<Vec<_>>()
-                            .try_into()
-                            .unwrap()
-                    })
-                    .collect(),
-            }
-        }
-
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-
-        let good_ciphertexts = vec![
-            random_ciphertexts(&mut rng, 1),
-            random_ciphertexts(&mut rng, 2),
-            random_ciphertexts(&mut rng, 10),
-        ];
-
-        for ciphertexts in &good_ciphertexts {
-            let bytes = ciphertexts.to_bytes();
-            let recovered = Ciphertexts::try_from_bytes(&bytes).unwrap();
-            assert_eq!(ciphertexts, &recovered);
-        }
-
-        // ciphertext for 0 receivers is invalid by default
-        let ciphertexts = random_ciphertexts(&mut rng, 0);
-        let bytes = ciphertexts.to_bytes();
-        assert!(Ciphertexts::try_from_bytes(&bytes).is_err());
-    }
-}

common/crypto/dkg/src/bte/keys.rs

@@ -1,875 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::bte::proof_discrete_log::ProofOfDiscreteLog;
-use crate::bte::{Epoch, Params, Tau};
-use crate::error::DkgError;
-use crate::utils::{deserialize_g1, deserialize_g2, deserialize_scalar};
-use bls12_381::{G1Projective, G2Projective, Scalar};
-use ff::Field;
-use group::GroupEncoding;
-use rand_core::RngCore;
-use zeroize::Zeroize;
-
-#[derive(Debug, Zeroize)]
-#[zeroize(drop)]
-#[cfg_attr(test, derive(Clone, PartialEq))]
-pub(crate) struct Node {
-    pub(crate) tau: Tau,
-
-    // g1^rho
-    pub(crate) a: G1Projective,
-
-    // g2^x
-    pub(crate) b: G2Projective,
-
-    // f_i^rho, up to lambda_t elements
-    pub(crate) ds: Vec<G2Projective>,
-
-    // fh_i^rho, always lambda_h elements
-    pub(crate) dh: Vec<G2Projective>,
-
-    // h^rho
-    pub(crate) e: G2Projective,
-}
-
-impl Node {
-    fn new_root(
-        a: G1Projective,
-        b: G2Projective,
-        ds: Vec<G2Projective>,
-        dh: Vec<G2Projective>,
-        e: G2Projective,
-    ) -> Self {
-        Node {
-            tau: Tau::new_root(),
-            a,
-            b,
-            ds,
-            dh,
-            e,
-        }
-    }
-
-    fn is_root(&self) -> bool {
-        self.tau.0.is_empty()
-    }
-
-    pub(crate) fn reblind(&mut self, params: &Params, mut rng: impl RngCore) {
-        let delta = Scalar::random(&mut rng);
-        self.a += G1Projective::generator() * delta;
-
-        // TODO: or do we have to do full tau evaluation here?
-        self.b += self.tau.evaluate_partial_f(params) * delta;
-        self.ds
-            .iter_mut()
-            .zip(params.fs.iter().skip(self.tau.height()))
-            .for_each(|(d_i, f_i)| *d_i += f_i * delta);
-        self.dh
-            .iter_mut()
-            .zip(params.fh.iter())
-            .for_each(|(d_i, f_i)| *d_i += f_i * delta);
-
-        self.e += params.h * delta;
-    }
-
-    // note: it's unsafe to use this method outside `try_update_to` as
-    // we have guaranteed there that `self` is parent of the target
-    // and that `self.tau != target_tau`
-    /// Given `self` with `Tau1` and `target_tau` with `Tau2`, such that `Tau1` prefixes `Tau2`,
-    /// i.e. `Tau2 == Tau1 || SUFFIX`, and `Tau2` is a leaf node, derive all required crypto material
-    /// for its construction.
-    fn derive_target_child_with_partials(
-        &self,
-        params: &Params,
-        target_tau: Tau,
-        partial_b: &G2Projective,
-        partial_f: &G2Projective,
-        mut rng: impl RngCore,
-    ) -> Self {
-        debug_assert!(self.tau.is_parent_of(&target_tau));
-        debug_assert_ne!(self.tau, target_tau);
-
-        let delta = Scalar::random(&mut rng);
-        let a = self.a + G1Projective::generator() * delta;
-        let b = partial_b + partial_f * delta;
-        let ds = self
-            .ds
-            .iter()
-            .zip(params.fs.iter())
-            .skip(target_tau.height())
-            .map(|(d_i, f_i)| d_i + f_i * delta)
-            .collect();
-        let dh = self
-            .dh
-            .iter()
-            .zip(params.fh.iter())
-            .map(|(dh_i, fh_i)| dh_i + fh_i * delta)
-            .collect();
-        let e = self.e + params.h * delta;
-
-        Node {
-            tau: target_tau,
-            a,
-            b,
-            ds,
-            dh,
-            e,
-        }
-    }
-
-    // note: it's unsafe to use this method outside `try_update_to` as
-    // we have guaranteed there that `self` is parent of the target
-    // and that `self.tau != target_tau`
-    /// Given `self` with `Tau1` and `most_direct_parent` with `Tau2`, such that `Tau1` prefixes `Tau2`,
-    /// i.e. `Tau2 == Tau1 || SUFFIX`, derive node with `Tau3 = Tau2 || 1`
-    fn derive_right_nonfinal_child_of_with_partials(
-        &self,
-        params: &Params,
-        most_direct_parent: Tau,
-        partial_b: &G2Projective,
-        partial_f: &G2Projective,
-        mut rng: impl RngCore,
-    ) -> Self {
-        let right_branch = most_direct_parent.right_child();
-
-        debug_assert!(self.tau.is_parent_of(&most_direct_parent));
-        debug_assert!(self.tau.is_parent_of(&right_branch));
-        debug_assert_ne!(self.tau, right_branch);
-
-        // n is height difference between self and the child
-        let n = right_branch.height() - self.tau.height();
-
-        // i is the index of the last bit we just added
-        let i = right_branch.height() - 1;
-
-        let delta = Scalar::random(&mut rng);
-        let a = self.a + G1Projective::generator() * delta;
-        let d0 = self.ds[n - 1];
-        let b = partial_b + d0 + (partial_f + params.fs[i]) * delta;
-        let ds = self
-            .ds
-            .iter()
-            .skip(n)
-            .zip(params.fs.iter().skip(right_branch.height()))
-            .map(|(d_i, f_i)| d_i + f_i * delta)
-            .collect();
-        let dh = self
-            .dh
-            .iter()
-            .zip(params.fh.iter())
-            .map(|(dh_i, fh_i)| dh_i + fh_i * delta)
-            .collect();
-
-        let e = self.e + params.h * delta;
-
-        Node {
-            tau: right_branch,
-            a,
-            b,
-            ds,
-            dh,
-            e,
-        }
-    }
-
-    // tau_bytes_len || tau || a || b || len_ds || ds || len_dh || dh || e
-    pub(crate) fn to_bytes(&self) -> Vec<u8> {
-        let g1_elements = 1;
-        let g2_elements = self.ds.len() + self.dh.len() + 2;
-
-        let tau_bytes = self.tau.to_bytes();
-
-        // the extra 12 comes from the triple u32 we use for encoding lengths of tau, ds and dh
-        let mut bytes =
-            Vec::with_capacity(tau_bytes.len() + g1_elements * 48 + g2_elements * 96 + 12);
-
-        bytes.extend_from_slice(&((tau_bytes.len() as u32).to_be_bytes()));
-        bytes.extend_from_slice(&tau_bytes);
-        bytes.extend_from_slice(self.a.to_bytes().as_ref());
-        bytes.extend_from_slice(self.b.to_bytes().as_ref());
-        bytes.extend_from_slice(&((self.ds.len() as u32).to_be_bytes()));
-        for d_i in &self.ds {
-            bytes.extend_from_slice(d_i.to_bytes().as_ref());
-        }
-        bytes.extend_from_slice(&((self.dh.len() as u32).to_be_bytes()));
-        for dh_i in &self.dh {
-            bytes.extend_from_slice(dh_i.to_bytes().as_ref());
-        }
-        bytes.extend_from_slice(self.e.to_bytes().as_ref());
-
-        bytes
-    }
-
-    pub fn try_from_bytes(bytes: &[u8]) -> Result<Self, DkgError> {
-        // at the very least we require bytes for:
-        // - tau_len ( 4 )
-        // - tau ( could be 0 for root node )
-        // - a ( 48 )
-        // - b ( 96 )
-        // - length indication of ds ( 4 )
-        // - length indication of dh ( 4 )
-        // - e ( 96 )
-        if bytes.len() < 4 + 48 + 96 + 4 + 4 + 96 {
-            return Err(DkgError::new_deserialization_failure(
-                "Node",
-                "insufficient number of bytes provided",
-            ));
-        }
-
-        let tau_len = u32::from_be_bytes((&bytes[..4]).try_into().unwrap()) as usize;
-        let mut i = 4;
-
-        let tau = Tau::try_from_bytes(&bytes[i..i + tau_len])?;
-        i += tau_len;
-
-        // perform another length check to account for bytes consumed by tau
-        if bytes[i..].len() < 48 + 96 + 4 + 4 + 96 {
-            return Err(DkgError::new_deserialization_failure(
-                "Node",
-                "insufficient number of bytes provided",
-            ));
-        }
-
-        let a = deserialize_g1(&bytes[i..i + 48]).ok_or_else(|| {
-            DkgError::new_deserialization_failure("Node.a", "invalid curve point")
-        })?;
-        i += 48;
-
-        let b = deserialize_g2(&bytes[i..i + 96]).ok_or_else(|| {
-            DkgError::new_deserialization_failure("Node.b", "invalid curve point")
-        })?;
-        i += 96;
-
-        let ds_len = u32::from_be_bytes((&bytes[i..i + 4]).try_into().unwrap()) as usize;
-        i += 4;
-
-        if bytes[i..].len() < ds_len * 96 + 4 {
-            return Err(DkgError::new_deserialization_failure(
-                "Node",
-                "insufficient number of bytes provided (ds)",
-            ));
-        }
-
-        let mut ds = Vec::with_capacity(ds_len);
-        for j in 0..ds_len {
-            let d_i = deserialize_g2(&bytes[i..i + 96]).ok_or_else(|| {
-                DkgError::new_deserialization_failure(
-                    format!("Node.ds_{}", j),
-                    "invalid curve point",
-                )
-            })?;
-
-            ds.push(d_i);
-            i += 96;
-        }
-
-        let dh_len = u32::from_be_bytes((&bytes[i..i + 4]).try_into().unwrap()) as usize;
-        i += 4;
-
-        if bytes[i..].len() != (dh_len + 1) * 96 {
-            return Err(DkgError::new_deserialization_failure(
-                "Node",
-                "insufficient number of bytes provided (dh)",
-            ));
-        }
-
-        let mut dh = Vec::with_capacity(dh_len);
-        for j in 0..dh_len {
-            let dh_i = deserialize_g2(&bytes[i..i + 96]).ok_or_else(|| {
-                DkgError::new_deserialization_failure(
-                    format!("Node.dh_{}", j),
-                    "invalid curve point",
-                )
-            })?;
-
-            dh.push(dh_i);
-            i += 96;
-        }
-
-        let e = deserialize_g2(&bytes[i..]).ok_or_else(|| {
-            DkgError::new_deserialization_failure("Node.h", "invalid curve point")
-        })?;
-
-        Ok(Node {
-            tau,
-            a,
-            b,
-            ds,
-            dh,
-            e,
-        })
-    }
-}
-
-// produces public key and a decryption key for the root of the tree
-pub fn keygen(params: &Params, mut rng: impl RngCore) -> (DecryptionKey, PublicKeyWithProof) {
-    let g1 = G1Projective::generator();
-    let g2 = G2Projective::generator();
-
-    let mut x = Scalar::random(&mut rng);
-    let y = g1 * x;
-
-    let proof = ProofOfDiscreteLog::construct(&mut rng, &y, &x);
-
-    let mut rho = Scalar::random(&mut rng);
-
-    let a = g1 * rho;
-    let b = g2 * x + params.f0 * rho;
-
-    let ds = params.fs.iter().map(|f_i| f_i * rho).collect();
-    let dh = params.fh.iter().map(|fh_i| fh_i * rho).collect();
-    let e = params.h * rho;
-
-    let dk = DecryptionKey::new_root(Node::new_root(a, b, ds, dh, e));
-
-    let public_key = PublicKey(y);
-    let key_with_proof = PublicKeyWithProof {
-        key: public_key,
-        proof,
-    };
-
-    x.zeroize();
-    rho.zeroize();
-
-    (dk, key_with_proof)
-}
-
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub struct PublicKey(pub(crate) G1Projective);
-
-impl PublicKey {
-    pub fn verify(&self, proof: &ProofOfDiscreteLog) -> bool {
-        proof.verify(&self.0)
-    }
-}
-
-#[derive(Debug)]
-#[cfg_attr(test, derive(PartialEq))]
-pub struct PublicKeyWithProof {
-    pub(crate) key: PublicKey,
-    pub(crate) proof: ProofOfDiscreteLog,
-}
-
-impl PublicKeyWithProof {
-    pub fn verify(&self) -> bool {
-        self.key.verify(&self.proof)
-    }
-
-    pub fn public_key(&self) -> &PublicKey {
-        &self.key
-    }
-
-    pub fn to_bytes(&self) -> Vec<u8> {
-        // we have 2 G1 elements and 1 Scalar
-        let mut bytes = Vec::with_capacity(2 * 48 + 32);
-        bytes.extend_from_slice(self.key.0.to_bytes().as_ref());
-        bytes.extend_from_slice(self.proof.rand_commitment.to_bytes().as_ref());
-        bytes.extend_from_slice(self.proof.response.to_bytes().as_ref());
-
-        bytes
-    }
-
-    pub fn try_from_bytes(bytes: &[u8]) -> Result<Self, DkgError> {
-        if bytes.len() != 2 * 48 + 32 {
-            return Err(DkgError::new_deserialization_failure(
-                "PublicKeyWithProof",
-                "provided bytes had invalid length",
-            ));
-        }
-
-        let y_bytes = &bytes[..48];
-        let commitment_bytes = &bytes[48..96];
-        let response_bytes = &bytes[96..];
-
-        let y = deserialize_g1(y_bytes).ok_or_else(|| {
-            DkgError::new_deserialization_failure("PublicKeyWithProof.key.0", "invalid curve point")
-        })?;
-
-        let rand_commitment = deserialize_g1(commitment_bytes).ok_or_else(|| {
-            DkgError::new_deserialization_failure(
-                "PublicKeyWithProof.proof.rand_commitment",
-                "invalid curve point",
-            )
-        })?;
-
-        let response = deserialize_scalar(response_bytes).ok_or_else(|| {
-            DkgError::new_deserialization_failure(
-                "PublicKeyWithProof.proof.response",
-                "invalid scalar",
-            )
-        })?;
-
-        Ok(PublicKeyWithProof {
-            key: PublicKey(y),
-            proof: ProofOfDiscreteLog {
-                rand_commitment,
-                response,
-            },
-        })
-    }
-}
-
-#[derive(Debug, Zeroize)]
-#[zeroize(drop)]
-#[cfg_attr(test, derive(PartialEq))]
-pub struct DecryptionKey {
-    // note that the nodes are ordered from "right" to "left"
-    pub(crate) nodes: Vec<Node>,
-}
-
-impl DecryptionKey {
-    fn new_root(root_node: Node) -> Self {
-        DecryptionKey {
-            nodes: vec![root_node],
-        }
-    }
-
-    fn current(&self) -> Result<&Node, DkgError> {
-        // we must have at least a single node, otherwise we have a malformed key
-        self.nodes.last().ok_or(DkgError::MalformedDecryptionKey)
-    }
-
-    pub fn current_epoch(&self, params: &Params) -> Result<Option<Epoch>, DkgError> {
-        let current_node = self.current()?;
-        if current_node.is_root() {
-            Ok(None)
-        } else {
-            Epoch::try_from_tau(&current_node.tau, params).map(Option::Some)
-        }
-    }
-
-    pub(crate) fn try_get_compatible_node(&self, epoch: Epoch) -> Result<&Node, DkgError> {
-        let tau = epoch.as_tau();
-        self.nodes
-            .iter()
-            .rev()
-            .find(|node| node.tau.is_parent_of(&tau))
-            .ok_or(DkgError::ExpiredKey)
-    }
-
-    pub fn try_update_to_next_epoch(
-        &mut self,
-        params: &Params,
-        mut rng: impl RngCore,
-    ) -> Result<(), DkgError> {
-        if self.nodes.is_empty() {
-            return Err(DkgError::MalformedDecryptionKey);
-        }
-
-        let mut target_epoch = Epoch::new(0);
-        if self.nodes.len() == 1 && self.nodes[0].is_root() {
-            return self.try_update_to(target_epoch, params, &mut rng);
-        }
-
-        // unwrap is fine as we have asserted self.nodes is not empty
-        self.nodes.pop().unwrap();
-
-        if let Some(tail) = self.nodes.last() {
-            target_epoch = tail.tau.lowest_valid_epoch_child(params)?;
-        } else {
-            // essentially our key consisted of only a single node and it wasn't a root,
-            // so either it was malformed or we somehow reached the final epoch and wanted to update
-            // beyond that. Either way, update to l + 1 is impossible
-            return Err(DkgError::MalformedDecryptionKey);
-        }
-
-        self.try_update_to(target_epoch, params, &mut rng)
-    }
-
-    /// Attempts to update `self` to the provided `epoch`. If the update is not possible,
-    /// because the target was in the past or the key is malformed, an error is returned.
-    ///
-    /// Note that this method mutates the key in place and if the original key was malformed,
-    /// there are no guarantees about its internal state post-call.
-    pub fn try_update_to(
-        &mut self,
-        target_epoch: Epoch,
-        params: &Params,
-        mut rng: impl RngCore,
-    ) -> Result<(), DkgError> {
-        if self.nodes.is_empty() {
-            // somehow we have an empty decryption key
-            return Err(DkgError::MalformedDecryptionKey);
-        }
-
-        // makes it easier to work with since we will be generating non-leaf nodes
-        let target_tau = target_epoch.as_tau();
-        let current_tau = &self.current()?.tau;
-
-        if current_tau == &target_tau {
-            // our key is already updated to the target
-            return Ok(());
-        }
-
-        if current_tau > &target_tau {
-            // we cannot derive keys for past epochs
-            return Err(DkgError::TargetEpochUpdateInThePast);
-        }
-
-        // drop the nodes that are no longer required and get the most direct parent for the target epoch available
-        let mut parent = loop {
-            // if pop() fails the key is malformed since we checked that the target_epoch > current_epoch,
-            // hence the update should have been possible
-            let tail = self.nodes.pop().ok_or(DkgError::MalformedDecryptionKey)?;
-            if tail.tau.is_parent_of(&target_tau) {
-                break tail;
-            }
-        };
-
-        // essentially the case of updating epoch n to n + 1, where n is even;
-        // in that case the last two nodes are [..., epoch_{n+1}, epoch_n]
-        // so we just have to reblind the n+1 node and we're done
-        if parent.tau == target_tau {
-            parent.reblind(params, &mut rng);
-            self.nodes.push(parent);
-            return Ok(());
-        }
-
-        // accumulators, note that the previous elements have already been included by the parent,
-        // i.e. for example for parent at height l <= n, b = g2^x * f0^rho * d1^{tau_1} * ... * dl^{tau_l}
-        // new_b_accumulator = b * d1^{tau_1} * d2^{tau_2} * ... * dn^{tau_n}
-        // new_f_accumulator = f0 * f1^{tau_1} * f2^{tau_2} * ... * fn^{tau_n} (up to lambda_t)
-        let mut new_b_accumulator = parent.b;
-        let mut new_f_accumulator = parent.tau.evaluate_partial_f(params);
-
-        let parent_height = parent.tau.height();
-
-        // path from the parent to the child
-        for (n, bit) in target_tau
-            .0
-            .iter()
-            .by_vals()
-            .skip(parent.tau.height())
-            .enumerate()
-        {
-            // ith bit of the [child] epoch
-            // note that n represents height difference between parent and the current bit
-            let i = n + parent_height;
-
-            // if the bit is NOT set, push the right '1' subtree (for future keys)
-            // so for example if given parent with some `PREFIX` tau and target_epoch being `PREFIX || 010`,
-            // in the first loop iteration we're going to look at bit `0` and
-            // derive child node `PREFIX || 1` so that in the future we could derive keys for all other epochs starting with `PREFIX || 1`
-            // in the next loop iteration we're going to look at bit `1` and simply update the accumulators,
-            // as we don't need to generate any "left" nodes as all of them would have constructed epochs that are already in the past
-            // finally, in the last iteration, we look at the bit `0` and derive node `PREFIX || 011`,
-            // i.e. the one that FOLLOWS the target node.
-            if !bit {
-                let direct_parent = target_tau.try_get_parent_at_height(i)?;
-
-                self.nodes
-                    .push(parent.derive_right_nonfinal_child_of_with_partials(
-                        params,
-                        direct_parent,
-                        &new_b_accumulator,
-                        &new_f_accumulator,
-                        &mut rng,
-                    ));
-            } else {
-                // only update the accumulators when the bit is set, as d^0 == identity, so there's
-                // no point in doing anything else;
-                // note that we don't have to generate any new nodes when going into the right branch
-                // of the tree as everything on the left would have been in the past, so we don't care about them
-                new_b_accumulator += parent.ds[n]; // add d0
-                new_f_accumulator += params.fs[i]; // f_i
-            }
-        }
-
-        self.nodes.push(parent.derive_target_child_with_partials(
-            params,
-            target_epoch.as_tau(),
-            &new_b_accumulator,
-            &new_f_accumulator,
-            &mut rng,
-        ));
-
-        Ok(())
-    }
-
-    pub fn to_bytes(&self) -> Vec<u8> {
-        let num_nodes = self.nodes.len() as u32;
-
-        // unfortunately we're not going to know the expected capacity
-        let mut bytes = Vec::new();
-        bytes.extend_from_slice(&num_nodes.to_be_bytes());
-
-        for node in &self.nodes {
-            let mut node_bytes = node.to_bytes();
-            bytes.extend_from_slice(&((node_bytes.len() as u32).to_be_bytes()));
-            bytes.append(&mut node_bytes)
-        }
-
-        bytes
-    }
-
-    pub fn try_from_bytes(b: &[u8]) -> Result<Self, DkgError> {
-        // we have to be able to read the length of nodes
-        if b.len() < 4 {
-            return Err(DkgError::new_deserialization_failure(
-                "DecryptionKey",
-                "insufficient number of bytes provided",
-            ));
-        }
-        let nodes_len = u32::from_be_bytes([b[0], b[1], b[2], b[3]]) as usize;
-        let mut nodes = Vec::with_capacity(nodes_len);
-
-        let mut i = 4;
-        for _ in 0..nodes_len {
-            // check if we can actually read the length...
-            if b[i..].len() < 4 {
-                return Err(DkgError::new_deserialization_failure(
-                    "DecryptionKey.Node",
-                    "insufficient number of bytes provided for BTE Node recovery",
-                ));
-            }
-
-            let node_bytes = u32::from_be_bytes([b[i], b[i + 1], b[i + 2], b[i + 3]]) as usize;
-            if b[i + 4..].len() < node_bytes {
-                return Err(DkgError::new_deserialization_failure(
-                    "DecryptionKey.Node",
-                    "insufficient number of bytes provided for BTE Node recovery",
-                ));
-            }
-            i += 4;
-
-            let node = Node::try_from_bytes(&b[i..i + node_bytes])?;
-            nodes.push(node);
-            i += node_bytes;
-        }
-
-        Ok(DecryptionKey { nodes })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::bte::setup;
-    use bitvec::bitvec;
-    use bitvec::order::Msb0;
-    use rand_core::SeedableRng;
-
-    #[test]
-    fn basic_coverage_nodes() {
-        // it's some basic test I've been performing when writing the update function, but figured
-        // might as well put it into a unit test. note that it doesn't check the entire structure,
-        // but just the few last nodes of low height
-
-        let params = setup();
-
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-
-        let (mut dk, _) = keygen(&params, &mut rng);
-
-        let root_node_copy = dk.nodes.clone();
-
-        // this is a root node
-        assert_eq!(dk.nodes.len(), 1);
-        assert!(dk.nodes[0].is_root());
-
-        // we have to have a node for right branch on each height (1, 01, 001, ... etc)
-        // plus an additional one for the two left-most leaves (epochs "0" and "1")
-        dk.try_update_to(Epoch::new(0), &params, &mut rng).unwrap();
-        assert_eq!(dk.nodes.len(), 33);
-
-        let expected_last = Tau::new(0);
-        // (and yes, I had to look up those names in a thesaurus)
-        let expected_penultimate = Tau::new(1);
-        // note that this value is 31bit long
-        let expected_antepenultimate = Tau(bitvec![u32, Msb0;
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 1
-        ]);
-
-        let mut nodes_iter = dk.nodes.iter().rev();
-        assert_eq!(expected_last, nodes_iter.next().unwrap().tau);
-        assert_eq!(expected_penultimate, nodes_iter.next().unwrap().tau);
-        assert_eq!(expected_antepenultimate, nodes_iter.next().unwrap().tau);
-
-        let mut epoch_zero_nodes = dk.nodes.clone();
-
-        // nodes for epoch1 should be identical for those for epoch0 minus the 00..00 leaf
-        dk.try_update_to(Epoch::new(1), &params, &mut rng).unwrap();
-        assert_eq!(dk.nodes.len(), 32);
-        epoch_zero_nodes.pop().unwrap();
-        assert_eq!(
-            epoch_zero_nodes
-                .iter()
-                .map(|node| node.tau.clone())
-                .collect::<Vec<_>>(),
-            dk.nodes
-                .iter()
-                .map(|node| node.tau.clone())
-                .collect::<Vec<_>>()
-        );
-
-        dk.try_update_to(Epoch::new(2), &params, &mut rng).unwrap();
-        dk.try_update_to(Epoch::new(3), &params, &mut rng).unwrap();
-        dk.try_update_to(Epoch::new(4), &params, &mut rng).unwrap();
-
-        let expected_last = Tau::new(4);
-        let expected_penultimate = Tau::new(5);
-        let expected_antepenultimate = Tau(bitvec![u32, Msb0;
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1
-        ]);
-        let expected_preantepenultimate = Tau(bitvec![u32, Msb0;
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1
-        ]);
-        assert_eq!(dk.nodes.len(), 32);
-        let mut nodes_iter = dk.nodes.iter().rev();
-        assert_eq!(expected_last, nodes_iter.next().unwrap().tau);
-        assert_eq!(expected_penultimate, nodes_iter.next().unwrap().tau);
-        assert_eq!(expected_antepenultimate, nodes_iter.next().unwrap().tau);
-        assert_eq!(expected_preantepenultimate, nodes_iter.next().unwrap().tau);
-
-        // the result should be the same of regardless if we update incrementally or go to the target immediately
-        let mut new_root = DecryptionKey {
-            nodes: root_node_copy,
-        };
-        new_root
-            .try_update_to(Epoch::new(4), &params, &mut rng)
-            .unwrap();
-        assert_eq!(
-            dk.nodes
-                .iter()
-                .map(|node| node.tau.clone())
-                .collect::<Vec<_>>(),
-            new_root
-                .nodes
-                .iter()
-                .map(|node| node.tau.clone())
-                .collect::<Vec<_>>()
-        );
-
-        // getting expected nodes for those epochs is non-trivial for test purposes, but the last node
-        // should ALWAYS be equal to the target epoch
-        dk.try_update_to(Epoch::new(42), &params, &mut rng).unwrap();
-        assert_eq!(dk.nodes.last().unwrap().tau, Tau::new(42));
-        dk.try_update_to(Epoch::new(123456), &params, &mut rng)
-            .unwrap();
-        assert_eq!(dk.nodes.last().unwrap().tau, Tau::new(123456));
-        dk.try_update_to(Epoch::new(3292547435), &params, &mut rng)
-            .unwrap();
-        assert_eq!(dk.nodes.last().unwrap().tau, Tau::new(3292547435));
-
-        // trying to go to past epochs fails
-        assert!(dk
-            .try_update_to(Epoch::new(531), &params, &mut rng)
-            .is_err())
-    }
-
-    #[test]
-    fn updating_to_next_epoch() {
-        let params = setup();
-
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-
-        let (mut dk, _) = keygen(&params, &mut rng);
-
-        // for root node current epoch is `None`
-        assert_eq!(None, dk.current_epoch(&params).unwrap());
-
-        // for root node it should result in epoch 0
-        dk.try_update_to_next_epoch(&params, &mut rng).unwrap();
-        assert_eq!(Some(Epoch::new(0)), dk.current_epoch(&params).unwrap());
-
-        dk.try_update_to_next_epoch(&params, &mut rng).unwrap();
-        assert_eq!(Some(Epoch::new(1)), dk.current_epoch(&params).unwrap());
-
-        dk.try_update_to_next_epoch(&params, &mut rng).unwrap();
-        assert_eq!(Some(Epoch::new(2)), dk.current_epoch(&params).unwrap());
-
-        // if we start from some non-root epoch, it should result in l + 1
-        dk.try_update_to(Epoch::new(42), &params, &mut rng).unwrap();
-        dk.try_update_to_next_epoch(&params, &mut rng).unwrap();
-        assert_eq!(Some(Epoch::new(43)), dk.current_epoch(&params).unwrap());
-
-        dk.try_update_to(Epoch::new(12345), &params, &mut rng)
-            .unwrap();
-        dk.try_update_to_next_epoch(&params, &mut rng).unwrap();
-        assert_eq!(Some(Epoch::new(12346)), dk.current_epoch(&params).unwrap());
-
-        dk.try_update_to(Epoch::new(3292547435), &params, &mut rng)
-            .unwrap();
-        dk.try_update_to_next_epoch(&params, &mut rng).unwrap();
-        assert_eq!(
-            Some(Epoch::new(3292547436)),
-            dk.current_epoch(&params).unwrap()
-        );
-    }
-
-    #[test]
-    fn public_key_with_proof_roundtrip() {
-        let params = setup();
-
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-
-        let (_, pk) = keygen(&params, &mut rng);
-        let bytes = pk.to_bytes();
-        let recovered = PublicKeyWithProof::try_from_bytes(&bytes).unwrap();
-
-        assert_eq!(pk, recovered)
-    }
-
-    #[test]
-    fn bte_node_roundtrip() {
-        let params = setup();
-
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-
-        let (mut dk, _) = keygen(&params, &mut rng);
-
-        let root_node = dk.nodes[0].clone();
-        let bytes = root_node.to_bytes();
-        let recovered = Node::try_from_bytes(&bytes).unwrap();
-        assert_eq!(root_node, recovered);
-
-        dk.try_update_to(Epoch::new(3292547435), &params, &mut rng)
-            .unwrap();
-        for node in &dk.nodes {
-            let bytes = node.to_bytes();
-            let recovered = Node::try_from_bytes(&bytes).unwrap();
-            assert_eq!(node, &recovered);
-        }
-    }
-
-    #[test]
-    fn decryption_key_node_roundtrip() {
-        let params = setup();
-
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-
-        let (mut dk, _) = keygen(&params, &mut rng);
-
-        let bytes = dk.to_bytes();
-        let recovered = DecryptionKey::try_from_bytes(&bytes).unwrap();
-        assert_eq!(dk, recovered);
-
-        dk.try_update_to(Epoch::new(0), &params, &mut rng).unwrap();
-        let bytes = dk.to_bytes();
-        let recovered = DecryptionKey::try_from_bytes(&bytes).unwrap();
-        assert_eq!(dk, recovered);
-
-        dk.try_update_to(Epoch::new(1), &params, &mut rng).unwrap();
-        let bytes = dk.to_bytes();
-        let recovered = DecryptionKey::try_from_bytes(&bytes).unwrap();
-        assert_eq!(dk, recovered);
-
-        dk.try_update_to(Epoch::new(42), &params, &mut rng).unwrap();
-        let bytes = dk.to_bytes();
-        let recovered = DecryptionKey::try_from_bytes(&bytes).unwrap();
-        assert_eq!(dk, recovered);
-
-        dk.try_update_to(Epoch::new(3292547435), &params, &mut rng)
-            .unwrap();
-        let bytes = dk.to_bytes();
-        let recovered = DecryptionKey::try_from_bytes(&bytes).unwrap();
-        assert_eq!(dk, recovered);
-    }
-}

common/crypto/dkg/src/bte/mod.rs

@@ -1,463 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::error::DkgError;
-use crate::utils::{hash_g2, RandomOracleBuilder};
-use crate::{Chunk, Share};
-use bitvec::field::BitField;
-use bitvec::order::Msb0;
-use bitvec::vec::BitVec;
-use bitvec::view::BitView;
-use bls12_381::{G1Affine, G1Projective, G2Affine, G2Prepared, G2Projective, Gt};
-use group::Curve;
-use lazy_static::lazy_static;
-use zeroize::Zeroize;
-
-pub mod encryption;
-pub mod keys;
-pub mod proof_chunking;
-pub mod proof_discrete_log;
-pub mod proof_sharing;
-
-pub use encryption::{decrypt_share, encrypt_shares, Ciphertexts};
-pub use keys::{keygen, DecryptionKey, PublicKey, PublicKeyWithProof};
-
-lazy_static! {
-    pub(crate) static ref PAIRING_BASE: Gt =
-        bls12_381::pairing(&G1Affine::generator(), &G2Affine::generator());
-    pub(crate) static ref G2_GENERATOR_PREPARED: G2Prepared =
-        G2Prepared::from(G2Affine::generator());
-    pub(crate) static ref DEFAULT_BSGS_TABLE: encryption::BabyStepGiantStepLookup =
-        encryption::BabyStepGiantStepLookup::default();
-}
-
-// Domain tries to follow guidelines specified by:
-// https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve-11#section-3.1
-const SETUP_DOMAIN: &[u8] = b"NYM_COCONUT_NIDKG_V01_CS01_WITH_BLS12381G2_XMD:SHA-256_SSWU_RO_SETUP";
-
-// this particular domain is not for curve hashing, but might as well also follow the same naming pattern
-const TREE_TAU_EXTENSION_DOMAIN: &[u8] = b"NYM_COCONUT_NIDKG_V01_CS01_SHA-256_TREE_EXTENSION";
-
-const MAX_EPOCHS_EXP: usize = 32;
-const HASH_SECURITY_PARAM: usize = 256;
-
-// note: CHUNK_BYTES * NUM_CHUNKS must equal to SCALAR_SIZE
-pub const CHUNK_BYTES: usize = 2;
-pub const NUM_CHUNKS: usize = 16;
-pub const SCALAR_SIZE: usize = 32;
-
-/// In paper B; number of distinct chunks
-pub const CHUNK_SIZE: usize = 1 << (CHUNK_BYTES << 3);
-
-pub(crate) type EpochStore = u32;
-
-#[derive(Clone, Debug, PartialEq, PartialOrd)]
-// None empty bitvec implies this is a root node
-pub(crate) struct Tau(BitVec<EpochStore, Msb0>);
-
-impl Tau {
-    pub fn new_root() -> Self {
-        Tau(BitVec::new())
-    }
-
-    // TODO: perhaps this should be explicitly moved to some test module
-    #[cfg(test)]
-    pub(crate) fn new(epoch: EpochStore) -> Self {
-        Tau(epoch.view_bits().to_bitvec())
-    }
-
-    #[allow(unused)]
-    pub fn left_child(&self) -> Self {
-        let mut child = self.0.clone();
-        child.push(false);
-        Tau(child)
-    }
-
-    pub fn right_child(&self) -> Self {
-        let mut child = self.0.clone();
-        child.push(true);
-        Tau(child)
-    }
-
-    pub fn is_leaf(&self, params: &Params) -> bool {
-        self.height() == params.lambda_t
-    }
-
-    pub fn try_get_parent_at_height(&self, height: usize) -> Result<Self, DkgError> {
-        if height > self.0.len() {
-            return Err(DkgError::NotAValidParent);
-        }
-
-        Ok(Tau(self.0[..height].to_bitvec()))
-    }
-
-    // essentially is this tau prefixing the other
-    pub fn is_parent_of(&self, other: &Tau) -> bool {
-        if self.0.len() > other.0.len() {
-            return false;
-        }
-
-        for (i, b) in self.0.iter().enumerate() {
-            if b != other.0[i] {
-                return false;
-            }
-        }
-
-        true
-    }
-
-    pub fn lowest_valid_epoch_child(&self, params: &Params) -> Result<Epoch, DkgError> {
-        if self.0.len() > params.lambda_t {
-            // this node is already BELOW a valid leaf-epoch node. it can only happen
-            // if either some invariant was broken or additional data was pushed to `tau`
-            // in order compute some intermediate results, but in that case this method should have
-            // never been called anyway. tl;dr: if this is called, the underlying key is malformed
-            return Err(DkgError::NotAValidParent);
-        }
-        let mut child = self.0.clone();
-        for _ in 0..(params.lambda_t - self.0.len()) {
-            child.push(false)
-        }
-
-        // the unwrap here is fine as we ensure we have exactly `params.tree_height` bits here
-        // (we could just propagate the error instead of unwraping and putting it behind an `Ok` anyway
-        // but I'd prefer to just blow up since this would be a serious error
-        Ok(Epoch::try_from_tau(&Tau(child), params).unwrap())
-    }
-
-    pub fn height(&self) -> usize {
-        self.0.len()
-    }
-
-    fn extend(
-        &self,
-        rr: &[G1Projective; NUM_CHUNKS],
-        ss: &[G1Projective; NUM_CHUNKS],
-        cc: &[[G1Projective; NUM_CHUNKS]],
-    ) -> Self {
-        let mut random_oracle_builder = RandomOracleBuilder::new(TREE_TAU_EXTENSION_DOMAIN);
-        random_oracle_builder.update_with_g1_elements(rr.iter());
-        random_oracle_builder.update_with_g1_elements(ss.iter());
-        for ciphertext_chunks in cc {
-            random_oracle_builder.update_with_g1_elements(ciphertext_chunks.iter());
-        }
-
-        let tau_mem = self.0.as_raw_slice();
-        assert_eq!(tau_mem.len(), 1, "tau length invariant was broken");
-        random_oracle_builder.update(&tau_mem[0].to_be_bytes());
-
-        let oracle_output = random_oracle_builder.finalize();
-        debug_assert_eq!(oracle_output.len() * 8, HASH_SECURITY_PARAM);
-
-        let mut extended_tau = self.clone();
-        for byte in oracle_output {
-            extended_tau
-                .0
-                .extend_from_bitslice(byte.view_bits::<Msb0>())
-        }
-
-        extended_tau
-    }
-
-    // considers all lambda_t + lambda_h bits
-    fn evaluate_f(&self, params: &Params) -> G2Projective {
-        self.0
-            .iter()
-            .by_vals()
-            .zip(params.fs.iter().chain(params.fh.iter()))
-            .filter(|(i, _)| *i)
-            .map(|(_, f_i)| f_i)
-            .fold(params.f0, |acc, f_i| acc + f_i)
-    }
-
-    // only considers up to lambda_t bits
-    fn evaluate_partial_f(&self, params: &Params) -> G2Projective {
-        self.0
-            .iter()
-            .by_vals()
-            .zip(params.fs.iter())
-            .filter(|(i, _)| *i)
-            .map(|(_, f_i)| f_i)
-            .fold(params.f0, |acc, f_i| acc + f_i)
-    }
-
-    pub(crate) fn to_bytes(&self) -> Vec<u8> {
-        let len_bytes = (self.0.len() as u32).to_be_bytes();
-        len_bytes
-            .into_iter()
-            .chain(self.0.chunks(8).map(BitField::load_be))
-            .collect()
-    }
-
-    pub(crate) fn try_from_bytes(b: &[u8]) -> Result<Self, DkgError> {
-        if b.len() < 4 {
-            return Err(DkgError::new_deserialization_failure(
-                "Tau",
-                "insufficient number of bytes provided",
-            ));
-        }
-        let tau_len = u32::from_be_bytes([b[0], b[1], b[2], b[3]]) as usize;
-
-        // maximum theoretical length
-        if tau_len > MAX_EPOCHS_EXP + HASH_SECURITY_PARAM {
-            return Err(DkgError::new_deserialization_failure(
-                "Tau",
-                format!(
-                    "malformed length {} is greater than maximum {}",
-                    tau_len,
-                    MAX_EPOCHS_EXP + HASH_SECURITY_PARAM
-                ),
-            ));
-        }
-
-        if tau_len == 0 {
-            if b.len() != 4 {
-                Err(DkgError::new_deserialization_failure(
-                    "Tau",
-                    "malformed bytes",
-                ))
-            } else {
-                Ok(Tau::new_root())
-            }
-        } else if b.len() == 4 {
-            Err(DkgError::new_deserialization_failure(
-                "Tau",
-                "insufficient number of bytes provided",
-            ))
-        } else {
-            let mut inner = BitVec::repeat(false, tau_len);
-            for (slot, &byte) in inner.chunks_mut(8).zip(b[4..].iter()) {
-                slot.store_be(byte);
-            }
-
-            Ok(Tau(inner))
-        }
-    }
-}
-
-impl Zeroize for Tau {
-    fn zeroize(&mut self) {
-        for v in self.0.as_raw_mut_slice() {
-            v.zeroize()
-        }
-    }
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, PartialOrd)]
-pub struct Epoch(EpochStore);
-
-impl Epoch {
-    pub fn new(value: EpochStore) -> Self {
-        Epoch(value)
-    }
-
-    pub(crate) fn as_tau(&self) -> Tau {
-        (*self).into()
-    }
-
-    pub(crate) fn as_extended_tau(
-        &self,
-        rr: &[G1Projective; NUM_CHUNKS],
-        ss: &[G1Projective; NUM_CHUNKS],
-        cc: &[[G1Projective; NUM_CHUNKS]],
-    ) -> Tau {
-        self.as_tau().extend(rr, ss, cc)
-    }
-
-    pub(crate) fn try_from_tau(tau: &Tau, params: &Params) -> Result<Self, DkgError> {
-        if !tau.is_leaf(params) {
-            Err(DkgError::MalformedEpoch)
-        } else {
-            Ok(Epoch(tau.0.load_be()))
-        }
-    }
-}
-
-impl From<Epoch> for Tau {
-    fn from(epoch: Epoch) -> Self {
-        Tau(epoch.0.view_bits().to_bitvec())
-    }
-}
-
-impl From<EpochStore> for Epoch {
-    fn from(epoch: EpochStore) -> Self {
-        Epoch(epoch)
-    }
-}
-
-pub struct Params {
-    /// Maximum size of an epoch, in bits.
-    pub lambda_t: usize,
-
-    /// Security parameter of our $H_{\Lamda_H}$ hash function
-    pub lambda_h: usize,
-
-    // keeping f0 separate from the rest of the curve points makes it easier to work with tau
-    f0: G2Projective,
-    fs: Vec<G2Projective>, // f_1, f_2, .... f_{lambda_t} in the paper
-    fh: Vec<G2Projective>, // f_{lambda_t+1}, f_{lambda_t+1}, .... f_{lambda_t+lambda_h} in the paper
-    h: G2Projective,
-
-    /// Precomputed `h` used for the miller loop
-    _h_prepared: G2Prepared,
-}
-
-pub fn setup() -> Params {
-    let f0 = hash_g2(b"f0", SETUP_DOMAIN);
-
-    let fs = (1..=MAX_EPOCHS_EXP)
-        .map(|i| hash_g2(format!("f{}", i), SETUP_DOMAIN))
-        .collect();
-
-    let fh = (0..HASH_SECURITY_PARAM)
-        .map(|i| hash_g2(format!("fh{}", i), SETUP_DOMAIN))
-        .collect();
-
-    let h = hash_g2(b"h", SETUP_DOMAIN);
-
-    Params {
-        lambda_t: MAX_EPOCHS_EXP,
-        lambda_h: HASH_SECURITY_PARAM,
-        f0,
-        fs,
-        fh,
-        h,
-        _h_prepared: G2Prepared::from(h.to_affine()),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use bitvec::bitvec;
-    use bitvec::order::Msb0;
-
-    #[test]
-    fn creating_tau_from_epoch() {
-        assert!(Tau::new_root().0.is_empty());
-
-        let zero = Tau::new(0);
-        assert!(zero.0.iter().by_vals().all(|b| !b));
-
-        let one = Tau::new(1);
-        let mut iter = one.0.iter().by_vals();
-        // first 31 bits are 0, the last one is 1
-        for _ in 0..31 {
-            assert!(!iter.next().unwrap())
-        }
-        assert!(iter.next().unwrap());
-
-        // 101010 in binary
-        let forty_two = Tau::new(42);
-        // first 26 bits are not set
-        let mut iter = forty_two.0.iter().by_vals();
-        for _ in 0..26 {
-            assert!(!iter.next().unwrap())
-        }
-        assert!(iter.next().unwrap());
-        assert!(!iter.next().unwrap());
-        assert!(iter.next().unwrap());
-        assert!(!iter.next().unwrap());
-        assert!(iter.next().unwrap());
-        assert!(!iter.next().unwrap());
-
-        // value that requires an actual u32 (i.e. takes 4 bytes to represent)
-        // 11000100_01000000_01001001_01101011 in binary
-        let big_val = Tau::new(3292547435);
-        let expected = bitvec![u32, Msb0;
-            1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1,
-            0, 1, 1
-        ];
-        assert_eq!(expected, big_val.0)
-    }
-
-    #[test]
-    fn getting_parent_at_height() {
-        let tau = Tau(bitvec![u32, Msb0; 1,0,1,1,0,0,1]);
-
-        let expected_0 = Tau(BitVec::new());
-        let expected_1 = Tau(bitvec![u32, Msb0; 1]);
-        let expected_5 = Tau(bitvec![u32, Msb0; 1,0,1,1,0]);
-
-        assert_eq!(expected_0, tau.try_get_parent_at_height(0).unwrap());
-        assert_eq!(expected_1, tau.try_get_parent_at_height(1).unwrap());
-        assert_eq!(expected_5, tau.try_get_parent_at_height(5).unwrap());
-        assert_eq!(tau, tau.try_get_parent_at_height(7).unwrap());
-        assert!(tau.try_get_parent_at_height(8).is_err())
-    }
-
-    #[test]
-    fn converting_tau_to_epoch() {
-        let params = setup();
-
-        let tau0: Tau = Epoch::new(0).into();
-        let tau1: Tau = Epoch::new(1).into();
-        let tau42: Tau = Epoch::new(42).into();
-        let tau_big: Tau = Epoch::new(3292547435).into();
-
-        assert_eq!(Epoch::new(0), Epoch::try_from_tau(&tau0, &params).unwrap());
-        assert_eq!(Epoch::new(1), Epoch::try_from_tau(&tau1, &params).unwrap());
-        assert_eq!(
-            Epoch::new(42),
-            Epoch::try_from_tau(&tau42, &params).unwrap()
-        );
-        assert_eq!(
-            Epoch::new(3292547435),
-            Epoch::try_from_tau(&tau_big, &params).unwrap()
-        );
-
-        assert!(Epoch::try_from_tau(&Tau(BitVec::new()), &params).is_err());
-        assert!(Epoch::try_from_tau(&Tau(bitvec![u32, Msb0; 1,0,1,1,0]), &params).is_err());
-        let _31bit_tau = Tau(bitvec![u32, Msb0;
-            1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1,
-            0, 1
-        ]);
-        assert!(Epoch::try_from_tau(&_31bit_tau, &params).is_err());
-
-        let _33bit_tau = Tau(bitvec![u32, Msb0;
-            1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1,
-            0, 1, 1, 0
-        ]);
-        assert!(Epoch::try_from_tau(&_33bit_tau, &params).is_err());
-    }
-
-    #[test]
-    fn tau_roundtrip() {
-        let good_taus = vec![
-            Tau::new_root(),
-            Tau::new(0),
-            Tau::new(1),
-            Tau::new(2),
-            Tau::new(42),
-            Tau::new(123456),
-            Tau::new(3292547435),
-            Tau::new(u32::MAX),
-        ];
-
-        for tau in good_taus {
-            let bytes = tau.to_bytes();
-            let recovered = Tau::try_from_bytes(&bytes).unwrap();
-            assert_eq!(tau, recovered);
-        }
-
-        // more valid variants
-        let mut another_tau = Tau::new(u32::MAX);
-        another_tau.0.push(true);
-        another_tau.0.push(false);
-        another_tau.0.push(true);
-
-        let bytes = another_tau.to_bytes();
-        let recovered = Tau::try_from_bytes(&bytes).unwrap();
-        assert_eq!(another_tau, recovered);
-
-        // ensure there are no panics
-        let big_length_bytes = [255, 255, 255, 255, 42];
-        assert!(Tau::try_from_bytes(&big_length_bytes).is_err());
-
-        assert!(Tau::try_from_bytes(&[]).is_err());
-        assert!(Tau::try_from_bytes(&[1, 1, 1, 1]).is_err());
-        assert!(Tau::try_from_bytes(&[0, 0, 0, 1]).is_err());
-        assert!(Tau::try_from_bytes(&[1, 0, 0, 0]).is_err());
-        assert!(Tau::try_from_bytes(&[1, 0, 0]).is_err());
-    }
-}

common/crypto/dkg/src/bte/proof_discrete_log.rs

@@ -1,94 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::utils::hash_to_scalar;
-use bls12_381::{G1Projective, Scalar};
-use ff::Field;
-use group::GroupEncoding;
-use rand_core::RngCore;
-use zeroize::Zeroize;
-
-// Domain tries to follow guidelines specified by:
-// https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve-11#section-3.1
-const DISCRETE_LOG_DOMAIN: &[u8] =
-    b"NYM_COCONUT_NIDKG_V01_CS01_WITH_BLS12381_XMD:SHA-256_SSWU_RO_PROOF_DISCRETE_LOG";
-
-#[derive(Debug)]
-#[cfg_attr(test, derive(PartialEq))]
-pub struct ProofOfDiscreteLog {
-    pub(crate) rand_commitment: G1Projective,
-    pub(crate) response: Scalar,
-}
-
-impl ProofOfDiscreteLog {
-    pub fn construct(mut rng: impl RngCore, public: &G1Projective, witness: &Scalar) -> Self {
-        let mut rand_x = Scalar::random(&mut rng);
-        let rand_commitment = G1Projective::generator() * rand_x;
-        let challenge = Self::compute_challenge(public, &rand_commitment);
-
-        let response = rand_x + challenge * witness;
-        rand_x.zeroize();
-
-        ProofOfDiscreteLog {
-            rand_commitment,
-            response,
-        }
-    }
-
-    // note: we don't have to explicitly check whether points are on correct curves / fields
-    // as if they weren't, they'd fail to get deserialized
-    pub fn verify(&self, public: &G1Projective) -> bool {
-        let challenge = Self::compute_challenge(public, &self.rand_commitment);
-
-        // y^c • a == g1^rand_x
-        public * challenge + self.rand_commitment == G1Projective::generator() * self.response
-    }
-
-    pub(crate) fn compute_challenge(public: &G1Projective, rand_commit: &G1Projective) -> Scalar {
-        let public_bytes = public.to_bytes();
-        let rand_commit_bytes = rand_commit.to_bytes();
-
-        let mut bytes = Vec::with_capacity(96);
-        bytes.extend_from_slice(public_bytes.as_ref());
-        bytes.extend_from_slice(rand_commit_bytes.as_ref());
-
-        hash_to_scalar(bytes, DISCRETE_LOG_DOMAIN)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use rand_core::SeedableRng;
-
-    #[test]
-    fn should_verify_a_valid_proof() {
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-
-        let witness = Scalar::random(&mut rng);
-        let public = G1Projective::generator() * witness;
-
-        let proof = ProofOfDiscreteLog::construct(&mut rng, &public, &witness);
-
-        assert!(proof.verify(&public))
-    }
-
-    #[test]
-    fn should_fail_on_invalid_proof() {
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-
-        let witness = Scalar::random(&mut rng);
-        let public = G1Projective::generator() * witness;
-
-        let other_witness = Scalar::random(&mut rng);
-        let other_public = G1Projective::generator() * other_witness;
-
-        let proof = ProofOfDiscreteLog::construct(&mut rng, &public, &witness);
-        let other_proof = ProofOfDiscreteLog::construct(&mut rng, &other_public, &other_witness);
-
-        assert!(!proof.verify(&other_public));
-        assert!(!other_proof.verify(&public));
-    }
-}

common/crypto/dkg/src/bte/proof_sharing.rs

@@ -1,615 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::bte::PublicKey;
-use crate::error::DkgError;
-use crate::interpolation::polynomial::PublicCoefficients;
-use crate::utils::{deserialize_g1, deserialize_g2, deserialize_scalar, hash_to_scalar};
-use crate::{NodeIndex, Share};
-use bls12_381::{G1Projective, G2Projective, Scalar};
-use ff::Field;
-use group::GroupEncoding;
-use rand_core::RngCore;
-use std::collections::BTreeMap;
-
-// Domain tries to follow guidelines specified by:
-// https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve-11#section-3.1
-const INSTANCE_DOMAIN: &[u8] =
-    b"NYM_COCONUT_NIDKG_V01_CS01_WITH_BLS12381_XMD:SHA-256_SSWU_RO_PROOF_SECRET_SHARING_INSTANCE";
-
-const CHALLENGE_DOMAIN: &[u8] =
-    b"NYM_COCONUT_NIDKG_V01_CS01_WITH_BLS12381_XMD:SHA-256_SSWU_RO_PROOF_SECRET_SHARING_CHALLENGE";
-
-#[cfg_attr(test, derive(Clone))]
-pub struct Instance<'a> {
-    public_keys: &'a BTreeMap<NodeIndex, PublicKey>,
-    public_coefficients: &'a PublicCoefficients,
-    combined_randomizer: &'a G1Projective,
-    combined_ciphertexts: &'a [G1Projective],
-}
-
-impl<'a> Instance<'a> {
-    pub fn new(
-        public_keys: &'a BTreeMap<NodeIndex, PublicKey>,
-        public_coefficients: &'a PublicCoefficients,
-        combined_randomizer: &'a G1Projective,
-        combined_ciphertexts: &'a [G1Projective],
-    ) -> Instance<'a> {
-        Instance {
-            public_keys,
-            public_coefficients,
-            combined_randomizer,
-            combined_ciphertexts,
-        }
-    }
-
-    fn hash_to_scalar(&self) -> Scalar {
-        let g1s = self.public_keys.len() + 1 + self.combined_ciphertexts.len();
-        let g2s = self.public_coefficients.size();
-        let mut bytes = Vec::with_capacity(g1s * 48 + g2s * 96);
-
-        for pk in self.public_keys.values() {
-            bytes.extend_from_slice(pk.0.to_bytes().as_ref())
-        }
-        for coeff in self.public_coefficients.inner() {
-            bytes.extend_from_slice(coeff.to_bytes().as_ref())
-        }
-        bytes.extend_from_slice(self.combined_randomizer.to_bytes().as_ref());
-
-        for ciphertext in self.combined_ciphertexts {
-            bytes.extend_from_slice(ciphertext.to_bytes().as_ref())
-        }
-
-        hash_to_scalar(&bytes, INSTANCE_DOMAIN)
-    }
-
-    fn validate(&self) -> bool {
-        if self.public_keys.is_empty() || self.public_coefficients.is_empty() {
-            return false;
-        }
-
-        if self.public_keys.len() != self.combined_ciphertexts.len() {
-            return false;
-        }
-
-        true
-    }
-}
-
-#[derive(Debug)]
-#[cfg_attr(test, derive(Clone, PartialEq))]
-pub struct ProofOfSecretSharing {
-    ff: G1Projective,
-    aa: G2Projective,
-    yy: G1Projective,
-    response_r: Scalar,
-    response_alpha: Scalar,
-}
-
-impl ProofOfSecretSharing {
-    pub fn construct(
-        mut rng: impl RngCore,
-        instance: Instance,
-        witness_r: &Scalar,
-        witnesses_s: &[Share],
-    ) -> Result<Self, DkgError> {
-        if !instance.validate() {
-            return Err(DkgError::MalformedProofOfSharingInstance);
-        }
-
-        let g1 = G1Projective::generator();
-        let g2 = G2Projective::generator();
-
-        let x = instance.hash_to_scalar();
-
-        // alpha, rho ← random_scalars
-        let alpha = Scalar::random(&mut rng);
-        let rho = Scalar::random(&mut rng);
-
-        // F = g1^rho
-        let ff = g1 * rho;
-        // A = g2^alpha
-        let aa = g2 * alpha;
-
-        // Y = (y_1^{x^1} • ...  y_n^{x^n})^rho • g1^alpha
-        // produce intermediate product (y_1^{x^1} • ...  y_n^{x^n})
-        let product =
-            instance
-                .public_keys
-                .values()
-                .rev()
-                .fold(G1Projective::identity(), |mut acc, pk| {
-                    acc += pk.0;
-                    acc *= x;
-                    acc
-                });
-        let yy = product * rho + g1 * alpha;
-
-        let challenge = Self::compute_challenge(&x, &ff, &aa, &yy);
-
-        // response_r = r • challenge + rho
-        let response_r = witness_r * challenge + rho;
-
-        // response_alpha = (share_1 • x^1 + ... share_n • x^n) • challenge + alpha
-        // produce intermediate sum (share_1 • x^1 + ... share_n • x^n)
-        let sum = witnesses_s
-            .iter()
-            .rev()
-            .fold(Scalar::zero(), |mut acc, witness| {
-                acc += witness.inner();
-                acc *= x;
-                acc
-            });
-        let response_alpha = sum * challenge + alpha;
-
-        Ok(ProofOfSecretSharing {
-            ff,
-            aa,
-            yy,
-            response_r,
-            response_alpha,
-        })
-    }
-
-    pub fn verify(&self, instance: Instance) -> bool {
-        if !instance.validate() {
-            return false;
-        }
-
-        let g1 = G1Projective::generator();
-        let g2 = G2Projective::generator();
-
-        let x = instance.hash_to_scalar();
-        let challenge = Self::compute_challenge(&x, &self.ff, &self.aa, &self.yy);
-
-        // check if R^challenge * F == g1^response_r
-        if instance.combined_randomizer * challenge + self.ff != g1 * self.response_r {
-            return false;
-        }
-
-        // check if
-        // (A_0 ^ (id1^0 • x^1 + ... idn^0 • x^n) • ... A_{t-1} ^ (id1^{t-1} • x^{t-1} + ... idn^{t-1} • x^n))^challenge * A
-        // ==
-        // g2^response_alpha
-        let product = instance
-            .public_coefficients
-            .inner()
-            .iter()
-            .enumerate()
-            .fold(G2Projective::identity(), |mut acc, (k, coeff)| {
-                // intermediate (id1^k • x^1 + ... + idn^k • x^n) sum
-                let sum: Scalar = instance
-                    .public_keys
-                    .keys()
-                    .enumerate()
-                    .map(|(i, node_id)| {
-                        let id_scalar = Scalar::from(*node_id);
-                        id_scalar.pow(&[k as u64, 0, 0, 0]) * x.pow(&[(i + 1) as u64, 0, 0, 0])
-                    })
-                    .sum();
-
-                acc += coeff * sum;
-                acc
-            });
-
-        if product * challenge + self.aa != g2 * self.response_alpha {
-            return false;
-        }
-
-        // check if
-        // (ciphertext_1 ^ (x^1) • ... ciphertext_n ^ (x^n)) ^ challenge • Y
-        // ==
-        // (pk_1 ^ (x^1) • ... pk_n ^ (x^n)) ^ response_r • g1^response_alpha
-
-        let product_1 = instance.combined_ciphertexts.iter().rev().fold(
-            G1Projective::identity(),
-            |mut acc, ciphertext| {
-                acc += ciphertext;
-                acc *= x;
-                acc
-            },
-        );
-
-        let product_2 =
-            instance
-                .public_keys
-                .values()
-                .rev()
-                .fold(G1Projective::identity(), |mut acc, pk| {
-                    acc += pk.0;
-                    acc *= x;
-                    acc
-                });
-
-        if product_1 * challenge + self.yy != product_2 * self.response_r + g1 * self.response_alpha
-        {
-            return false;
-        }
-
-        true
-    }
-
-    pub(crate) fn compute_challenge(
-        commitment: &Scalar,
-        blinder_g1: &G1Projective,
-        blinder_g2: &G2Projective,
-        blinded_instance: &G1Projective,
-    ) -> Scalar {
-        let mut bytes = Vec::with_capacity(224);
-
-        bytes.extend_from_slice(commitment.to_bytes().as_ref());
-        bytes.extend_from_slice(blinder_g1.to_bytes().as_ref());
-        bytes.extend_from_slice(blinder_g2.to_bytes().as_ref());
-        bytes.extend_from_slice(blinded_instance.to_bytes().as_ref());
-
-        hash_to_scalar(&bytes, CHALLENGE_DOMAIN)
-    }
-
-    pub(crate) fn to_bytes(&self) -> Vec<u8> {
-        // we have 2 G1 elements, single G2 element and 2 scalars
-        let mut bytes = Vec::with_capacity(2 * 48 + 96 + 2 * 32);
-        bytes.extend_from_slice(self.ff.to_bytes().as_ref());
-        bytes.extend_from_slice(self.aa.to_bytes().as_ref());
-        bytes.extend_from_slice(self.yy.to_bytes().as_ref());
-        bytes.extend_from_slice(self.response_r.to_bytes().as_ref());
-        bytes.extend_from_slice(self.response_alpha.to_bytes().as_ref());
-        bytes
-    }
-
-    pub(crate) fn try_from_bytes(bytes: &[u8]) -> Result<Self, DkgError> {
-        if bytes.len() != 2 * 48 + 96 + 2 * 32 {
-            return Err(DkgError::new_deserialization_failure(
-                "ProofOfSecretSharing",
-                "invalid number of bytes provided",
-            ));
-        }
-
-        let mut i = 0;
-        let f = deserialize_g1(&bytes[i..i + 48]).ok_or_else(|| {
-            DkgError::new_deserialization_failure("ProofOfSecretSharing.f", "invalid curve point")
-        })?;
-        i += 48;
-
-        let a = deserialize_g2(&bytes[i..i + 96]).ok_or_else(|| {
-            DkgError::new_deserialization_failure("ProofOfSecretSharing.a", "invalid curve point")
-        })?;
-        i += 96;
-
-        let y = deserialize_g1(&bytes[i..i + 48]).ok_or_else(|| {
-            DkgError::new_deserialization_failure("ProofOfSecretSharing.y", "invalid curve point")
-        })?;
-        i += 48;
-
-        let response_r = deserialize_scalar(&bytes[i..i + 32]).ok_or_else(|| {
-            DkgError::new_deserialization_failure(
-                "ProofOfSecretSharing.response_r",
-                "invalid scalar",
-            )
-        })?;
-        i += 32;
-
-        let response_alpha = deserialize_scalar(&bytes[i..]).ok_or_else(|| {
-            DkgError::new_deserialization_failure(
-                "ProofOfSecretSharing.response_alpha",
-                "invalid scalar",
-            )
-        })?;
-
-        Ok(ProofOfSecretSharing {
-            ff: f,
-            aa: a,
-            yy: y,
-            response_r,
-            response_alpha,
-        })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::interpolation::polynomial::Polynomial;
-    use group::Group;
-    use rand_core::SeedableRng;
-
-    const NODES: u64 = 50;
-    const THRESHOLD: u64 = 40;
-
-    fn setup(
-        mut rng: impl RngCore,
-    ) -> (
-        BTreeMap<NodeIndex, PublicKey>,
-        PublicCoefficients,
-        G1Projective,
-        Vec<G1Projective>,
-        Scalar,
-        Vec<Share>,
-    ) {
-        let g1 = G1Projective::generator();
-
-        let mut pks = BTreeMap::new();
-        let polynomial = Polynomial::new_random(&mut rng, THRESHOLD - 1);
-        let public_coefficients = polynomial.public_coefficients();
-
-        let mut shares: Vec<Share> = Vec::new();
-        let mut node_indices = (0..NODES).map(|_| rng.next_u64()).collect::<Vec<_>>();
-        node_indices.sort_unstable();
-
-        for node_index in node_indices {
-            let share = polynomial.evaluate_at(&Scalar::from(node_index));
-            shares.push(share.into());
-            pks.insert(node_index, PublicKey(g1 * Scalar::random(&mut rng)));
-        }
-
-        let r = Scalar::random(&mut rng);
-        let rr = g1 * r;
-
-        let ciphertexts = pks
-            .values()
-            .zip(&shares)
-            .map(|(pk, share)| pk.0 * r + g1 * share.inner())
-            .collect();
-        (pks, public_coefficients, rr, ciphertexts, r, shares)
-    }
-
-    #[test]
-    fn should_fail_to_create_proof_with_invalid_instance() {
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-
-        let g1 = G1Projective::generator();
-
-        let mut pks = BTreeMap::new();
-        let polynomial = Polynomial::new_random(&mut rng, THRESHOLD - 1);
-        let public_coefficients = polynomial.public_coefficients();
-
-        let mut shares: Vec<Share> = Vec::new();
-        for _ in 0..NODES {
-            let node_index = rng.next_u64();
-            let share = polynomial.evaluate_at(&Scalar::from(node_index));
-            shares.push(share.into());
-            pks.insert(node_index, PublicKey(g1 * Scalar::random(&mut rng)));
-        }
-
-        let r = Scalar::random(&mut rng);
-        let rr = g1 * r;
-
-        let mut shares = Vec::new();
-        for node_id in 1..NODES + 1 {
-            let share = polynomial.evaluate_at(&Scalar::from(node_id));
-            shares.push(share);
-        }
-
-        let ciphertexts = pks
-            .values()
-            .zip(&shares)
-            .map(|(pk, share)| pk.0 * r + g1 * share)
-            .collect::<Vec<_>>();
-
-        // no public keys
-        let bad_instance1 = Instance {
-            public_keys: &BTreeMap::new(),
-            public_coefficients: &public_coefficients,
-            combined_randomizer: &rr,
-            combined_ciphertexts: &ciphertexts,
-        };
-        assert!(!bad_instance1.validate());
-
-        // no public coefficients
-        let bad_instance2 = Instance {
-            public_keys: &pks,
-            public_coefficients: &PublicCoefficients {
-                coefficients: Vec::new(),
-            },
-            combined_randomizer: &rr,
-            combined_ciphertexts: &ciphertexts,
-        };
-        assert!(!bad_instance2.validate());
-
-        // no ciphertexts
-        let bad_instance3 = Instance {
-            public_keys: &pks,
-            public_coefficients: &public_coefficients,
-            combined_randomizer: &rr,
-            combined_ciphertexts: &[],
-        };
-        assert!(!bad_instance3.validate());
-
-        // public_keys.len() != combined_ciphertexts.len()
-        let bad_ciphertexts = ciphertexts.iter().skip(1).cloned().collect::<Vec<_>>();
-
-        let bad_instance4 = Instance {
-            public_keys: &pks,
-            public_coefficients: &public_coefficients,
-            combined_randomizer: &rr,
-            combined_ciphertexts: &bad_ciphertexts,
-        };
-        assert!(!bad_instance4.validate());
-
-        // changed index of one of the keys
-        let mut bad_pks = pks.clone();
-        let first_id = bad_pks.keys().copied().take(1).collect::<Vec<_>>();
-        let first_val = bad_pks.remove(&first_id[0]).unwrap();
-        bad_pks.insert(rng.next_u64(), first_val);
-
-        let bad_instance5 = Instance {
-            public_keys: &bad_pks,
-            public_coefficients: &public_coefficients,
-            combined_randomizer: &rr,
-            combined_ciphertexts: &bad_ciphertexts,
-        };
-        assert!(!bad_instance5.validate());
-
-        let good_instance = Instance {
-            public_keys: &pks,
-            public_coefficients: &public_coefficients,
-            combined_randomizer: &rr,
-            combined_ciphertexts: &ciphertexts,
-        };
-        assert!(good_instance.validate())
-    }
-
-    #[test]
-    fn should_verify_a_valid_proof() {
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-
-        let (public_keys, public_coefficients, rr, ciphertexts, r, shares) = setup(&mut rng);
-
-        let instance = Instance {
-            public_keys: &public_keys,
-            public_coefficients: &public_coefficients,
-            combined_randomizer: &rr,
-            combined_ciphertexts: &ciphertexts,
-        };
-
-        let sharing_proof =
-            ProofOfSecretSharing::construct(&mut rng, instance.clone(), &r, &shares).unwrap();
-
-        assert!(sharing_proof.verify(instance))
-    }
-
-    #[test]
-    fn should_fail_to_verify_proof_with_invalid_instance() {
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-
-        let (public_keys, public_coefficients, rr, ciphertexts, r, shares) = setup(&mut rng);
-
-        let instance = Instance {
-            public_keys: &public_keys,
-            public_coefficients: &public_coefficients,
-            combined_randomizer: &rr,
-            combined_ciphertexts: &ciphertexts,
-        };
-
-        let sharing_proof =
-            ProofOfSecretSharing::construct(&mut rng, instance.clone(), &r, &shares).unwrap();
-
-        // no public keys
-        let bad_instance1 = Instance {
-            public_keys: &BTreeMap::new(),
-            public_coefficients: &public_coefficients,
-            combined_randomizer: &rr,
-            combined_ciphertexts: &ciphertexts,
-        };
-        assert!(!sharing_proof.verify(bad_instance1));
-
-        // no public coefficients
-        let bad_instance2 = Instance {
-            public_keys: &public_keys,
-            public_coefficients: &PublicCoefficients {
-                coefficients: Vec::new(),
-            },
-            combined_randomizer: &rr,
-            combined_ciphertexts: &ciphertexts,
-        };
-        assert!(!sharing_proof.verify(bad_instance2));
-
-        // no ciphertexts
-        let bad_instance3 = Instance {
-            public_keys: &public_keys,
-            public_coefficients: &public_coefficients,
-            combined_randomizer: &rr,
-            combined_ciphertexts: &[],
-        };
-        assert!(!sharing_proof.verify(bad_instance3));
-
-        // public_keys.len() != combined_ciphertexts.len()
-        let bad_ciphertexts = ciphertexts.iter().skip(1).cloned().collect::<Vec<_>>();
-
-        let bad_instance4 = Instance {
-            public_keys: &public_keys,
-            public_coefficients: &public_coefficients,
-            combined_randomizer: &rr,
-            combined_ciphertexts: &bad_ciphertexts,
-        };
-        assert!(!sharing_proof.verify(bad_instance4));
-    }
-
-    #[test]
-    fn should_fail_to_verify_proof_with_wrong_instance() {
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-
-        let (public_keys, public_coefficients, rr, ciphertexts, r, shares) = setup(&mut rng);
-
-        let instance = Instance {
-            public_keys: &public_keys,
-            public_coefficients: &public_coefficients,
-            combined_randomizer: &rr,
-            combined_ciphertexts: &ciphertexts,
-        };
-
-        let sharing_proof =
-            ProofOfSecretSharing::construct(&mut rng, instance.clone(), &r, &shares).unwrap();
-
-        let (public_keys, public_coefficients, rr, ciphertexts, _, _) = setup(&mut rng);
-        let bad_instance = Instance {
-            public_keys: &public_keys,
-            public_coefficients: &public_coefficients,
-            combined_randomizer: &rr,
-            combined_ciphertexts: &ciphertexts,
-        };
-
-        assert!(!sharing_proof.verify(bad_instance));
-    }
-
-    #[test]
-    fn should_fail_to_verify_invalid_proof() {
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-
-        let (public_keys, public_coefficients, rr, ciphertexts, r, shares) = setup(&mut rng);
-
-        let instance = Instance {
-            public_keys: &public_keys,
-            public_coefficients: &public_coefficients,
-            combined_randomizer: &rr,
-            combined_ciphertexts: &ciphertexts,
-        };
-
-        let good_proof =
-            ProofOfSecretSharing::construct(&mut rng, instance.clone(), &r, &shares).unwrap();
-
-        let mut bad_proof = good_proof.clone();
-        bad_proof.ff = G1Projective::generator();
-        assert!(!bad_proof.verify(instance.clone()));
-
-        let mut bad_proof = good_proof.clone();
-        bad_proof.aa = G2Projective::generator();
-        assert!(!bad_proof.verify(instance.clone()));
-
-        let mut bad_proof = good_proof.clone();
-        bad_proof.yy = G1Projective::generator();
-        assert!(!bad_proof.verify(instance.clone()));
-
-        let mut bad_proof = good_proof.clone();
-        bad_proof.response_r = Scalar::from(42);
-        assert!(!bad_proof.verify(instance.clone()));
-
-        let mut bad_proof = good_proof;
-        bad_proof.response_alpha = Scalar::from(42);
-        assert!(!bad_proof.verify(instance));
-    }
-
-    #[test]
-    fn proof_of_secret_sharing_roundtrip() {
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-
-        let proof_fixture = ProofOfSecretSharing {
-            ff: G1Projective::random(&mut rng),
-            aa: G2Projective::random(&mut rng),
-            yy: G1Projective::random(&mut rng),
-            response_r: Scalar::random(&mut rng),
-            response_alpha: Scalar::random(&mut rng),
-        };
-
-        let bytes = proof_fixture.to_bytes();
-        let recovered = ProofOfSecretSharing::try_from_bytes(&bytes).unwrap();
-        assert_eq!(proof_fixture, recovered);
-
-        assert!(ProofOfSecretSharing::try_from_bytes(&bytes[1..]).is_err())
-    }
-}

common/crypto/dkg/src/dealing.rs

@@ -1,500 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::bte::proof_chunking::ProofOfChunking;
-use crate::bte::proof_sharing::ProofOfSecretSharing;
-use crate::bte::{
-    encrypt_shares, proof_chunking, proof_sharing, Ciphertexts, Epoch, Params, PublicKey,
-};
-use crate::error::DkgError;
-use crate::interpolation::polynomial::{Polynomial, PublicCoefficients};
-use crate::interpolation::{
-    perform_lagrangian_interpolation_at_origin, perform_lagrangian_interpolation_at_x,
-};
-use crate::{NodeIndex, Share, Threshold};
-use bls12_381::{G2Projective, Scalar};
-use rand_core::RngCore;
-use std::collections::BTreeMap;
-use zeroize::Zeroize;
-
-#[derive(Debug)]
-#[cfg_attr(test, derive(PartialEq))]
-pub struct Dealing {
-    pub public_coefficients: PublicCoefficients,
-    pub ciphertexts: Ciphertexts,
-    pub proof_of_chunking: ProofOfChunking,
-    pub proof_of_sharing: ProofOfSecretSharing,
-}
-
-impl Dealing {
-    // I'm not a big fan of this function signature, but I'm not clear on how to improve it while
-    // allowing the dealer to skip decryption of its own share if it was also one of the receivers
-    pub fn create(
-        mut rng: impl RngCore,
-        params: &Params,
-        dealer_index: NodeIndex,
-        threshold: Threshold,
-        epoch: Epoch,
-        // BTreeMap ensures the keys are sorted by their indices
-        receivers: &BTreeMap<NodeIndex, PublicKey>,
-        prior_resharing_secret: Option<Scalar>,
-    ) -> (Self, Option<Share>) {
-        assert!(threshold > 0);
-
-        let mut polynomial = Polynomial::new_random(&mut rng, threshold - 1);
-        if let Some(prior_secret) = prior_resharing_secret {
-            polynomial.set_constant_coefficient(prior_secret)
-        }
-
-        let mut shares = receivers
-            .keys()
-            .map(|&node_index| polynomial.evaluate_at(&Scalar::from(node_index)).into())
-            .collect::<Vec<_>>();
-
-        let remote_share_key_pairs = shares
-            .iter()
-            .zip(receivers.values())
-            .map(|(share, key)| (share, key))
-            .collect::<Vec<_>>();
-        let ordered_public_keys = receivers.values().copied().collect::<Vec<_>>();
-
-        let (ciphertexts, hazmat) =
-            encrypt_shares(&remote_share_key_pairs, epoch, params, &mut rng);
-
-        // create proofs of knowledge
-        let chunking_instance = proof_chunking::Instance::new(&ordered_public_keys, &ciphertexts);
-        let proof_of_chunking =
-            ProofOfChunking::construct(&mut rng, chunking_instance, hazmat.r(), &shares)
-                .expect("failed to construct proof of chunking");
-
-        let combined_ciphertexts = ciphertexts.combine_ciphertexts();
-        let mut combined_r = hazmat.combine_rs();
-        let combined_rr = ciphertexts.combine_rs();
-
-        let public_coefficients = polynomial.public_coefficients();
-        let sharing_instance = proof_sharing::Instance::new(
-            receivers,
-            &public_coefficients,
-            &combined_rr,
-            &combined_ciphertexts,
-        );
-        let proof_of_sharing =
-            ProofOfSecretSharing::construct(&mut rng, sharing_instance, &combined_r, &shares)
-                .expect("failed to construct proof of secret sharing");
-
-        combined_r.zeroize();
-
-        let dealing = Dealing {
-            public_coefficients,
-            ciphertexts,
-            proof_of_chunking,
-            proof_of_sharing,
-        };
-
-        let dealers_key_index = receivers
-            .keys()
-            .position(|node_index| node_index == &dealer_index);
-        if let Some(dealer_key_index) = dealers_key_index {
-            let dealers_share = shares.remove(dealer_key_index);
-            shares.zeroize();
-            (dealing, Some(dealers_share))
-        } else {
-            (dealing, None)
-        }
-    }
-
-    // rather than returning a bool for whether the dealing is valid or not, a Result is returned
-    // instead so that we would have more information regarding a possible failure cause
-    pub fn verify(
-        &self,
-        params: &Params,
-        epoch: Epoch,
-        threshold: Threshold,
-        receivers: &BTreeMap<NodeIndex, PublicKey>,
-        prior_resharing_public: Option<G2Projective>,
-    ) -> Result<(), DkgError> {
-        if threshold == 0 || threshold as usize > receivers.len() {
-            return Err(DkgError::InvalidThreshold {
-                actual: threshold as usize,
-                participating: receivers.len(),
-            });
-        }
-
-        if self.ciphertexts.ciphertext_chunks.len() != receivers.len() {
-            return Err(DkgError::WrongCiphertextSize {
-                actual: self.ciphertexts.ciphertext_chunks.len(),
-                expected: receivers.len(),
-            });
-        }
-
-        if self.public_coefficients.size() != threshold as usize {
-            return Err(DkgError::WrongPublicCoefficientsSize {
-                actual: self.public_coefficients.size(),
-                expected: threshold as usize,
-            });
-        }
-
-        if !self.ciphertexts.verify_integrity(params, epoch) {
-            return Err(DkgError::FailedCiphertextIntegrityCheck);
-        }
-
-        // TODO: perhaps change the underlying arguments in proofs of knowledge to avoid this allocation?
-        let sorted_receivers = receivers.values().copied().collect::<Vec<_>>();
-
-        let chunking_instance = proof_chunking::Instance::new(&sorted_receivers, &self.ciphertexts);
-        if !self.proof_of_chunking.verify(chunking_instance) {
-            return Err(DkgError::InvalidProofOfChunking);
-        }
-
-        let combined_randomizer = &self.ciphertexts.combine_rs();
-        let combined_ciphertexts = &self.ciphertexts.combine_ciphertexts();
-
-        let sharing_instance = proof_sharing::Instance::new(
-            receivers,
-            &self.public_coefficients,
-            combined_randomizer,
-            combined_ciphertexts,
-        );
-
-        if !self.proof_of_sharing.verify(sharing_instance) {
-            return Err(DkgError::InvalidProofOfSharing);
-        }
-
-        if let Some(prior_public) = prior_resharing_public {
-            let dealt_public = &self.public_coefficients[0];
-            if dealt_public != &prior_public {
-                return Err(DkgError::InvalidResharing);
-            }
-        }
-
-        Ok(())
-    }
-
-    // coeff_len || coeff || cc_len || cc || pi_c_len || pi_c || pi_s_len || pi_s
-    pub fn to_bytes(&self) -> Vec<u8> {
-        let mut bytes = Vec::new();
-
-        let mut coefficients_bytes = self.public_coefficients.to_bytes();
-        bytes.extend_from_slice(&(coefficients_bytes.len() as u32).to_be_bytes());
-        bytes.append(&mut coefficients_bytes);
-
-        let mut ciphertexts_bytes = self.ciphertexts.to_bytes();
-        bytes.extend_from_slice(&(ciphertexts_bytes.len() as u32).to_be_bytes());
-        bytes.append(&mut ciphertexts_bytes);
-
-        let mut proof_sharing_bytes = self.proof_of_sharing.to_bytes();
-        bytes.extend_from_slice(&(proof_sharing_bytes.len() as u32).to_be_bytes());
-        bytes.append(&mut proof_sharing_bytes);
-
-        let mut proof_chunking_bytes = self.proof_of_chunking.to_bytes();
-        bytes.extend_from_slice(&(proof_chunking_bytes.len() as u32).to_be_bytes());
-        bytes.append(&mut proof_chunking_bytes);
-
-        bytes
-    }
-
-    pub fn try_from_bytes(bytes: &[u8]) -> Result<Self, DkgError> {
-        // can we read the length of serialized public coefficients?
-        if bytes.len() < 4 {
-            return Err(DkgError::new_deserialization_failure(
-                "Dealing",
-                "insufficient number of bytes provided",
-            ));
-        }
-
-        let mut i = 0;
-        let coefficients_bytes_len =
-            u32::from_be_bytes((&bytes[i..i + 4]).try_into().unwrap()) as usize;
-        i += 4;
-        let public_coefficients =
-            PublicCoefficients::try_from_bytes(&bytes[i..i + coefficients_bytes_len])?;
-        i += coefficients_bytes_len;
-
-        let ciphertexts_bytes_len =
-            u32::from_be_bytes((&bytes[i..i + 4]).try_into().unwrap()) as usize;
-        i += 4;
-        let ciphertexts = Ciphertexts::try_from_bytes(&bytes[i..i + ciphertexts_bytes_len])?;
-        i += ciphertexts_bytes_len;
-
-        let proof_of_sharing_bytes_len =
-            u32::from_be_bytes((&bytes[i..i + 4]).try_into().unwrap()) as usize;
-        i += 4;
-        let proof_of_sharing =
-            ProofOfSecretSharing::try_from_bytes(&bytes[i..i + proof_of_sharing_bytes_len])?;
-        i += proof_of_sharing_bytes_len;
-
-        let proof_of_chunking_bytes_len =
-            u32::from_be_bytes((&bytes[i..i + 4]).try_into().unwrap()) as usize;
-        i += 4;
-
-        if bytes[i..].len() != proof_of_chunking_bytes_len {
-            return Err(DkgError::new_deserialization_failure(
-                "Dealing",
-                "invalid number of bytes provided",
-            ));
-        }
-
-        let proof_of_chunking = ProofOfChunking::try_from_bytes(&bytes[i..])?;
-
-        Ok(Dealing {
-            public_coefficients,
-            ciphertexts,
-            proof_of_chunking,
-            proof_of_sharing,
-        })
-    }
-}
-
-// this assumes all dealings have been verified
-pub fn try_recover_verification_keys(
-    dealings: &[Dealing],
-    threshold: Threshold,
-    receivers: &BTreeMap<NodeIndex, PublicKey>,
-) -> Result<(G2Projective, Vec<G2Projective>), DkgError> {
-    if dealings.is_empty() {
-        return Err(DkgError::NoDealingsAvailable);
-    }
-
-    let threshold_usize = threshold as usize;
-
-    if !dealings
-        .iter()
-        .all(|dealing| dealing.public_coefficients.size() == threshold_usize)
-    {
-        return Err(DkgError::MismatchedDealings);
-    }
-
-    // currently we expect every dealer to also be a receiver. This restriction might be relaxed in the future
-    if dealings.len() != receivers.len() {
-        return Err(DkgError::MismatchedDealings);
-    }
-
-    let indices = receivers.keys().collect::<Vec<_>>();
-
-    // Compute A0, ..., A_{t-1}
-    let mut interpolated_coefficients = Vec::with_capacity(threshold_usize);
-    for k in 0..threshold_usize {
-        let mut samples = Vec::with_capacity(indices.len());
-        for (j, dealing) in dealings.iter().enumerate() {
-            samples.push((
-                Scalar::from(*indices[j]),
-                *dealing.public_coefficients.nth(k),
-            ))
-        }
-        let interpolated = perform_lagrangian_interpolation_at_origin(&samples)?;
-        interpolated_coefficients.push(interpolated);
-    }
-
-    let master_verification_key = interpolated_coefficients[0];
-
-    let interpolated_coefficients = PublicCoefficients {
-        coefficients: interpolated_coefficients,
-    };
-
-    // shvk_j = A0^{j^0} * A1^{j^1} * ... * A_{t-1}^{j^{t-1}}
-    let verification_key_shares = receivers
-        .keys()
-        .map(|index| interpolated_coefficients.evaluate_at(&Scalar::from(*index)))
-        .collect();
-
-    Ok((master_verification_key, verification_key_shares))
-}
-
-pub fn verify_verification_keys(
-    master_key: &G2Projective,
-    shares: &[G2Projective],
-    receivers: &BTreeMap<NodeIndex, PublicKey>,
-    threshold: Threshold,
-) -> Result<(), DkgError> {
-    if shares.len() != receivers.len() {
-        return Err(DkgError::NotEnoughReceiversProvided);
-    }
-
-    if threshold as usize > receivers.len() {
-        return Err(DkgError::InvalidThreshold {
-            actual: threshold as usize,
-            participating: receivers.len(),
-        });
-    }
-
-    let indices = receivers.keys().copied().collect::<Vec<_>>();
-
-    let indices_with_origin = std::iter::once(&0)
-        .chain(receivers.keys())
-        .collect::<Vec<_>>();
-    let all_shares = std::iter::once(master_key)
-        .chain(shares.iter())
-        .collect::<Vec<_>>();
-
-    for (i, share) in shares.iter().enumerate() {
-        let samples = indices_with_origin
-            .iter()
-            .zip(all_shares.iter())
-            .map(|(&node_index, &share)| (Scalar::from(*node_index), *share))
-            .take(threshold as usize)
-            .collect::<Vec<_>>();
-        let interpolated =
-            perform_lagrangian_interpolation_at_x(&Scalar::from(indices[i]), &samples)?;
-        if share != &interpolated {
-            return Err(DkgError::MismatchedVerificationKey);
-        }
-    }
-
-    Ok(())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::bte::{decrypt_share, keygen, setup};
-    use crate::combine_shares;
-    use rand_core::SeedableRng;
-
-    #[test]
-    fn recovering_partial_verification_keys() {
-        // START OF SETUP
-        let dummy_seed = [42u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-        let params = setup();
-
-        let threshold = 2;
-        let node_indices = vec![1, 4, 7];
-
-        let mut receivers = BTreeMap::new();
-        let mut full_keys = Vec::new();
-        for index in &node_indices {
-            let (dk, pk) = keygen(&params, &mut rng);
-            receivers.insert(*index, *pk.public_key());
-            full_keys.push((dk, pk))
-        }
-
-        // start off in a defined epoch (i.e. not root);
-        let epoch = Epoch::new(2);
-
-        let dealings = node_indices
-            .iter()
-            .map(|&dealer_index| {
-                Dealing::create(
-                    &mut rng,
-                    &params,
-                    dealer_index,
-                    threshold,
-                    epoch,
-                    &receivers,
-                    None,
-                )
-                .0
-            })
-            .collect::<Vec<_>>();
-
-        let mut derived_secrets = Vec::new();
-        for (i, (ref mut dk, _)) in full_keys.iter_mut().enumerate() {
-            dk.try_update_to(epoch, &params, &mut rng).unwrap();
-
-            let shares = dealings
-                .iter()
-                .map(|dealing| decrypt_share(dk, i, &dealing.ciphertexts, epoch, None).unwrap())
-                .collect();
-            derived_secrets.push(
-                combine_shares(shares, &receivers.keys().copied().collect::<Vec<_>>()).unwrap(),
-            )
-        }
-
-        let master_secret = perform_lagrangian_interpolation_at_origin(&[
-            (Scalar::from(node_indices[2]), derived_secrets[2]),
-            (Scalar::from(node_indices[1]), derived_secrets[1]),
-        ])
-        .unwrap();
-
-        // END OF SETUP
-        let (recovered_master, recovered_partials) =
-            try_recover_verification_keys(&dealings, threshold, &receivers).unwrap();
-
-        let g2 = G2Projective::generator();
-        assert_eq!(g2 * master_secret, recovered_master);
-
-        assert_eq!(g2 * derived_secrets[0], recovered_partials[0]);
-        assert_eq!(g2 * derived_secrets[1], recovered_partials[1]);
-        assert_eq!(g2 * derived_secrets[2], recovered_partials[2]);
-    }
-
-    #[test]
-    fn verifying_partial_verification_keys() {
-        let dummy_seed = [42u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-        let params = setup();
-
-        let threshold = 2;
-        let node_indices = vec![1, 4, 7];
-
-        let mut receivers = BTreeMap::new();
-        let mut full_keys = Vec::new();
-        for index in &node_indices {
-            let (dk, pk) = keygen(&params, &mut rng);
-            receivers.insert(*index, *pk.public_key());
-            full_keys.push((dk, pk))
-        }
-
-        // start off in a defined epoch (i.e. not root);
-        let epoch = Epoch::new(2);
-
-        let dealings = node_indices
-            .iter()
-            .map(|&dealer_index| {
-                Dealing::create(
-                    &mut rng,
-                    &params,
-                    dealer_index,
-                    threshold,
-                    epoch,
-                    &receivers,
-                    None,
-                )
-                .0
-            })
-            .collect::<Vec<_>>();
-
-        let (recovered_master, recovered_partials) =
-            try_recover_verification_keys(&dealings, threshold, &receivers).unwrap();
-
-        assert!(verify_verification_keys(
-            &recovered_master,
-            &recovered_partials,
-            &receivers,
-            threshold
-        )
-        .is_ok())
-    }
-
-    #[test]
-    fn dealing_roundtrip() {
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-        let params = setup();
-
-        let parties = 5;
-        let threshold = ((parties as f32 * 2.) / 3. + 1.) as Threshold;
-        let node_indices = (1..=parties).collect::<Vec<_>>();
-        let epoch = Epoch::new(2);
-
-        let mut receivers = BTreeMap::new();
-        for index in &node_indices {
-            let (_, pk) = keygen(&params, &mut rng);
-            receivers.insert(*index, *pk.public_key());
-        }
-
-        let (dealing, _) = Dealing::create(
-            &mut rng,
-            &params,
-            node_indices[0],
-            threshold,
-            epoch,
-            &receivers,
-            None,
-        );
-
-        let bytes = dealing.to_bytes();
-        let recovered = Dealing::try_from_bytes(&bytes).unwrap();
-        assert_eq!(dealing, recovered);
-    }
-}

common/crypto/dkg/src/error.rs

@@ -1,114 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use thiserror::Error;
-
-#[derive(Debug, Error)]
-pub enum DkgError {
-    #[error("Provided set of values contained duplicate coordinate")]
-    DuplicateCoordinate,
-
-    #[error("The public key is malformed")]
-    MalformedPublicKey,
-
-    #[error("The decryption key is malformed")]
-    MalformedDecryptionKey,
-
-    #[error("Could not solve the discrete log")]
-    UnsolvableDiscreteLog,
-
-    #[error("Received share is malformed")]
-    MalformedShare,
-
-    #[error("The share encrypted under index {0} doesn't exist")]
-    UnavailableCiphertext(usize),
-
-    #[error("The provided lookup table is mismatched")]
-    MismatchedLookupTable,
-
-    #[error("Failed to verify proof of discrete logarithm")]
-    InvalidProofOfDiscreteLog,
-
-    #[error("Tried to construct proof of sharing with an invalid instance")]
-    MalformedProofOfSharingInstance,
-
-    #[error("Tried to construct proof of chunking with an invalid instance")]
-    MalformedProofOfChunkingInstance,
-
-    #[error("Aborted construction of proof of chunking - could not complete it within specified number of attempts")]
-    AbortedProofOfChunking,
-
-    #[error("Tried to update the decryption key to an epoch in the past")]
-    TargetEpochUpdateInThePast,
-
-    #[error("Provided epoch is malformed")]
-    MalformedEpoch,
-
-    #[error("Provided node is not a valid parent")]
-    NotAValidParent,
-
-    #[error("Provided decryption key has expired")]
-    ExpiredKey,
-
-    #[error("Provided threshold value ({actual}) is either 0 or larger than the total number of the participating parties ({participating})")]
-    InvalidThreshold { actual: usize, participating: usize },
-
-    #[error(
-    "Provided ciphertext has been generated for a different number of participating parties (expected: {expected}, actual: {actual})"
-    )]
-    WrongCiphertextSize { actual: usize, expected: usize },
-
-    #[error(
-    "Provided public coefficients have been generated for a different number of participating parties (expected: {expected}, actual: {actual})"
-    )]
-    WrongPublicCoefficientsSize { actual: usize, expected: usize },
-
-    #[error("The provided ciphertexts failed integrity check")]
-    FailedCiphertextIntegrityCheck,
-
-    #[error("The provided proof of secret sharing was invalid")]
-    InvalidProofOfSharing,
-
-    #[error("The provided proof of chunking was invalid")]
-    InvalidProofOfChunking,
-
-    #[error("Failed to deserialize {name} - {reason}")]
-    DeserializationFailure { name: String, reason: String },
-
-    #[error("No dealings were provided")]
-    NoDealingsAvailable,
-
-    #[error("Provided dealings were created under different parameters")]
-    MismatchedDealings,
-
-    #[error(
-        "Not enough dealings are available. We have {available} while require at least {required}"
-    )]
-    NotEnoughDealingsAvailable { available: usize, required: usize },
-
-    #[error("Received different number of x and y coordinates for lagrangian interpolation (xs: {x}, ys: {y})")]
-    MismatchedLagrangianSamplesLengths { x: usize, y: usize },
-
-    #[error("Derived partial verification key is mismatched")]
-    MismatchedVerificationKey,
-
-    #[error("Insufficient number of receivers was provided")]
-    NotEnoughReceiversProvided,
-
-    #[error(
-        "The reshared dealing has different public constant coefficient than its prior variant"
-    )]
-    InvalidResharing,
-}
-
-impl DkgError {
-    pub fn new_deserialization_failure<S: Into<String>, T: Into<String>>(
-        name: S,
-        reason: T,
-    ) -> DkgError {
-        DkgError::DeserializationFailure {
-            name: name.into(),
-            reason: reason.into(),
-        }
-    }
-}

common/crypto/dkg/src/interpolation/mod.rs

@@ -1,157 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::error::DkgError;
-use bls12_381::Scalar;
-use core::iter::Sum;
-use core::ops::Mul;
-use std::collections::HashSet;
-
-pub mod polynomial;
-
-fn contains_duplicates(vals: &[Scalar]) -> bool {
-    let mut set = HashSet::new();
-
-    for x in vals {
-        if !set.insert(x.to_bytes()) {
-            return true;
-        }
-    }
-
-    false
-}
-
-#[inline]
-fn generate_lagrangian_coefficients_at_x(
-    x: &Scalar,
-    points: &[Scalar],
-) -> Result<Vec<Scalar>, DkgError> {
-    let num_points = points.len();
-    if num_points == 0 {
-        return Ok(Vec::new());
-    } else if num_points == 1 {
-        return Ok(vec![Scalar::one()]);
-    }
-
-    if contains_duplicates(points) {
-        return Err(DkgError::DuplicateCoordinate);
-    }
-
-    let mut res = Vec::with_capacity(points.len());
-
-    for (i, xi) in points.iter().enumerate() {
-        let mut numerator = Scalar::one();
-        let mut denominator = Scalar::one();
-
-        for (j, xj) in points.iter().enumerate() {
-            if j != i {
-                // numerator = (x - xs[0]) * ... * (x - xs[j]), j != i
-                numerator *= x - xj;
-
-                // denominator = (xs[i] - x[0]) * ... * (xs[i] - x[j]), j != i
-                denominator *= xi - xj;
-            }
-        }
-
-        // 1 / denominator
-        let inv: Scalar =
-            Option::from(denominator.invert()).ok_or(DkgError::DuplicateCoordinate)?;
-
-        // numerator / denominator
-        res.push(numerator * inv)
-    }
-
-    Ok(res)
-}
-
-/// Performs a Lagrange interpolation at specified x for a polynomial defined by set of coordinates
-/// (x, f(x)), where x is a `Scalar` and f(x) is a generic type that can be obtained by evaluating `f` at `x`.
-/// It can be used for Scalars, G1 and G2 points.
-pub fn perform_lagrangian_interpolation_at_x<T>(
-    x: &Scalar,
-    points: &[(Scalar, T)],
-) -> Result<T, DkgError>
-where
-    T: Sum,
-    for<'a> &'a T: Mul<Scalar, Output = T>,
-{
-    let xs = points.iter().map(|p| p.0).collect::<Vec<_>>();
-    let coefficients = generate_lagrangian_coefficients_at_x(x, &xs)?;
-
-    Ok(coefficients
-        .into_iter()
-        .zip(points.iter().map(|p| &p.1))
-        .map(|(coeff, y)| y * coeff)
-        .sum())
-}
-
-/// Performs a Lagrange interpolation at the origin for a polynomial defined by set of coordinates
-/// (x, f(x)), where x is a `Scalar` and f(x) is a generic type that can be obtained by evaluating `f` at `x`.
-/// It can be used for Scalars, G1 and G2 points.
-pub fn perform_lagrangian_interpolation_at_origin<T>(points: &[(Scalar, T)]) -> Result<T, DkgError>
-where
-    T: Sum,
-    for<'a> &'a T: Mul<Scalar, Output = T>,
-{
-    perform_lagrangian_interpolation_at_x(&Scalar::zero(), points)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn performing_lagrangian_scalar_interpolation_at_origin() {
-        // x^2 + 3
-        // x, f(x):
-        // 1, 4,
-        // 2, 7,
-        // 3, 12,
-        let points = vec![
-            (Scalar::from(1), Scalar::from(4)),
-            (Scalar::from(2), Scalar::from(7)),
-            (Scalar::from(3), Scalar::from(12)),
-        ];
-        assert_eq!(
-            Scalar::from(3),
-            perform_lagrangian_interpolation_at_origin(&points).unwrap()
-        );
-
-        // x^3 + 3x^2 - 5x + 11
-        // x, f(x):
-        // 1, 10
-        // 2, 21
-        // 3, 50
-        // 4, 103
-        let points = vec![
-            (Scalar::from(1), Scalar::from(10)),
-            (Scalar::from(2), Scalar::from(21)),
-            (Scalar::from(3), Scalar::from(50)),
-            (Scalar::from(4), Scalar::from(103)),
-        ];
-        assert_eq!(
-            Scalar::from(11),
-            perform_lagrangian_interpolation_at_origin(&points).unwrap()
-        );
-
-        // more points than it is required
-        // x^2 + x + 10
-        // x, f(x)
-        // 1, 12
-        // 2, 16
-        // 3, 22
-        // 4, 30
-        // 5, 40
-        let points = vec![
-            (Scalar::from(1), Scalar::from(12)),
-            (Scalar::from(2), Scalar::from(16)),
-            (Scalar::from(3), Scalar::from(22)),
-            (Scalar::from(4), Scalar::from(30)),
-            (Scalar::from(5), Scalar::from(40)),
-        ];
-        assert_eq!(
-            Scalar::from(10),
-            perform_lagrangian_interpolation_at_origin(&points).unwrap()
-        );
-    }
-}

common/crypto/dkg/src/interpolation/polynomial.rs

@@ -1,395 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::error::DkgError;
-use crate::utils::deserialize_g2;
-use bls12_381::{G2Projective, Scalar};
-use ff::Field;
-use group::GroupEncoding;
-use rand_core::RngCore;
-use std::ops::{Add, Index, IndexMut};
-use zeroize::Zeroize;
-
-#[derive(Clone, Debug, PartialEq)]
-pub struct PublicCoefficients {
-    pub(crate) coefficients: Vec<G2Projective>,
-}
-
-impl PublicCoefficients {
-    pub(crate) fn size(&self) -> usize {
-        self.coefficients.len()
-    }
-
-    pub(crate) fn nth(&self, n: usize) -> &G2Projective {
-        &self.coefficients[n]
-    }
-
-    pub(crate) fn is_empty(&self) -> bool {
-        self.coefficients.is_empty()
-    }
-
-    pub(crate) fn inner(&self) -> &[G2Projective] {
-        &self.coefficients
-    }
-
-    pub(crate) fn evaluate_at(&self, x: &Scalar) -> G2Projective {
-        if self.coefficients.is_empty() {
-            G2Projective::identity()
-            // if x is zero then we can ignore most of the expensive computation and
-            // just return the last term of the polynomial
-        } else if x.is_zero().into() {
-            // we checked that coefficients are not empty so unwrap here is fine
-            *self.coefficients.first().unwrap()
-        } else {
-            self.coefficients
-                .iter()
-                .enumerate()
-                // coefficient[n] * x ^ n
-                .map(|(i, coefficient)| coefficient * x.pow(&[i as u64, 0, 0, 0]))
-                .sum()
-        }
-    }
-
-    pub(crate) fn to_bytes(&self) -> Vec<u8> {
-        let coeffs = self.coefficients.len();
-        let mut bytes = Vec::with_capacity(4 + 96 * coeffs);
-        bytes.extend_from_slice(&((coeffs as u32).to_be_bytes()));
-        for coeff in &self.coefficients {
-            bytes.extend_from_slice(coeff.to_bytes().as_ref())
-        }
-
-        bytes
-    }
-
-    pub(crate) fn try_from_bytes(b: &[u8]) -> Result<Self, DkgError> {
-        if b.len() < 4 {
-            return Err(DkgError::new_deserialization_failure(
-                "PublicCoefficients",
-                "insufficient number of bytes provided",
-            ));
-        }
-
-        let coeffs = u32::from_be_bytes([b[0], b[1], b[2], b[3]]) as usize;
-        let mut coefficients = Vec::with_capacity(coeffs);
-
-        if b.len() != 4 + coeffs * 96 {
-            return Err(DkgError::new_deserialization_failure(
-                "PublicCoefficients",
-                "insufficient number of bytes provided",
-            ));
-        }
-
-        let mut i = 4;
-        for _ in 0..coeffs {
-            let coefficient = deserialize_g2(&b[i..i + 96]).ok_or_else(|| {
-                DkgError::new_deserialization_failure(
-                    "PublicCoefficients.coefficient",
-                    "invalid curve point",
-                )
-            })?;
-
-            coefficients.push(coefficient);
-            i += 96;
-        }
-
-        Ok(PublicCoefficients { coefficients })
-    }
-}
-
-impl Index<usize> for PublicCoefficients {
-    type Output = G2Projective;
-
-    fn index(&self, index: usize) -> &Self::Output {
-        self.coefficients.index(index)
-    }
-}
-
-impl IndexMut<usize> for PublicCoefficients {
-    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
-        self.coefficients.index_mut(index)
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, Zeroize)]
-#[zeroize(drop)]
-pub struct Polynomial {
-    coefficients: Vec<Scalar>,
-}
-
-impl Polynomial {
-    // for polynomial of degree n, we generate n+1 values
-    // (for example for degree 1, like y = x + 2, we need [2,1])
-    /// Creates new pseudorandom polynomial of specified degree.
-    pub fn new_random(mut rng: impl RngCore, degree: u64) -> Self {
-        Polynomial {
-            coefficients: (0..=degree).map(|_| Scalar::random(&mut rng)).collect(),
-        }
-    }
-
-    /// Creates new polynomial with provided coefficients.
-    pub fn new(coefficients: Vec<Scalar>) -> Self {
-        Polynomial { coefficients }
-    }
-
-    pub fn set_constant_coefficient(&mut self, value: Scalar) {
-        if self.coefficients.is_empty() {
-            self.coefficients = vec![value]
-        } else {
-            self.coefficients[0] = value
-        }
-    }
-
-    /// Creates a zero-polynomial, i.e. p(x) = 0
-    pub const fn zero() -> Self {
-        Polynomial {
-            coefficients: Vec::new(),
-        }
-    }
-
-    /// Returns public coefficients associated with this polynomial.
-    pub fn public_coefficients(&self) -> PublicCoefficients {
-        let g2 = G2Projective::generator();
-        let coefficients = self.coefficients.iter().map(|a_i| g2 * a_i).collect();
-
-        PublicCoefficients { coefficients }
-    }
-
-    /// Evaluates the polynomial at point x.
-    pub fn evaluate_at(&self, x: &Scalar) -> Scalar {
-        if self.coefficients.is_empty() {
-            Scalar::zero()
-            // if x is zero then we can ignore most of the expensive computation and
-            // just return the last term of the polynomial
-        } else if x.is_zero().into() {
-            // we checked that coefficients are not empty so unwrap here is fine
-            *self.coefficients.first().unwrap()
-        } else {
-            self.coefficients
-                .iter()
-                .enumerate()
-                // coefficient[n] * x ^ n
-                .map(|(i, coefficient)| coefficient * x.pow(&[i as u64, 0, 0, 0]))
-                .sum()
-        }
-    }
-}
-
-impl Index<usize> for Polynomial {
-    type Output = Scalar;
-
-    fn index(&self, index: usize) -> &Self::Output {
-        self.coefficients.index(index)
-    }
-}
-
-impl IndexMut<usize> for Polynomial {
-    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
-        self.coefficients.index_mut(index)
-    }
-}
-
-impl<'b> Add<&'b Polynomial> for Polynomial {
-    type Output = Polynomial;
-
-    fn add(self, rhs: &'b Polynomial) -> Polynomial {
-        &self + rhs
-    }
-}
-
-impl<'a> Add<Polynomial> for &'a Polynomial {
-    type Output = Polynomial;
-
-    fn add(self, rhs: Polynomial) -> Polynomial {
-        self + &rhs
-    }
-}
-
-impl Add<Polynomial> for Polynomial {
-    type Output = Polynomial;
-
-    fn add(self, rhs: Polynomial) -> Polynomial {
-        &self + &rhs
-    }
-}
-
-impl<'a, 'b> Add<&'b Polynomial> for &'a Polynomial {
-    type Output = Polynomial;
-
-    fn add(self, rhs: &'b Polynomial) -> Self::Output {
-        let len = self.coefficients.len();
-        let rhs_len = rhs.coefficients.len();
-
-        // to have easier bound checks
-        if rhs_len > len {
-            return rhs + self;
-        }
-
-        // we know len >= rhs_len and hence the output will also be of size len
-        let mut res = Vec::with_capacity(len);
-
-        for i in 0..len {
-            if let Some(rhs_coeff) = rhs.coefficients.get(i) {
-                res.push(self[i] + rhs_coeff)
-            } else {
-                res.push(self[i])
-            }
-        }
-
-        Polynomial { coefficients: res }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use rand_core::SeedableRng;
-
-    #[test]
-    fn polynomial_evaluation() {
-        // y = 42 (it should be 42 regardless of x)
-        let poly = Polynomial {
-            coefficients: vec![Scalar::from(42)],
-        };
-
-        assert_eq!(Scalar::from(42), poly.evaluate_at(&Scalar::from(1)));
-        assert_eq!(Scalar::from(42), poly.evaluate_at(&Scalar::from(0)));
-        assert_eq!(Scalar::from(42), poly.evaluate_at(&Scalar::from(10)));
-
-        // y = x + 10, at x = 2 (exp: 12)
-        let poly = Polynomial {
-            coefficients: vec![Scalar::from(10), Scalar::from(1)],
-        };
-
-        assert_eq!(Scalar::from(12), poly.evaluate_at(&Scalar::from(2)));
-
-        // y = x^4 - 5x^2 + 2x - 3, at x = 3 (exp: 39)
-        let poly = Polynomial {
-            coefficients: vec![
-                (-Scalar::from(3)),
-                Scalar::from(2),
-                (-Scalar::from(5)),
-                Scalar::zero(),
-                Scalar::from(1),
-            ],
-        };
-
-        assert_eq!(Scalar::from(39), poly.evaluate_at(&Scalar::from(3)));
-
-        // empty polynomial
-        let poly = Polynomial::zero();
-
-        // should always be 0
-        assert_eq!(Scalar::from(0), poly.evaluate_at(&Scalar::from(1)));
-        assert_eq!(Scalar::from(0), poly.evaluate_at(&Scalar::from(0)));
-        assert_eq!(Scalar::from(0), poly.evaluate_at(&Scalar::from(10)));
-    }
-
-    #[test]
-    fn polynomial_addition() {
-        let empty = Polynomial::zero();
-        let p1 = Polynomial {
-            coefficients: vec![Scalar::from(1), Scalar::from(2), Scalar::from(3)],
-        };
-        let p2 = Polynomial {
-            coefficients: vec![Scalar::from(4), Scalar::from(5)],
-        };
-        let expected_sum = Polynomial {
-            coefficients: vec![Scalar::from(5), Scalar::from(7), Scalar::from(3)],
-        };
-
-        assert_eq!(p1, &p1 + &empty);
-        assert_eq!(p1, empty + &p1);
-        assert_eq!(expected_sum, &p1 + &p2);
-        assert_eq!(expected_sum, &p2 + &p1);
-    }
-
-    #[test]
-    fn public_coefficients_evaluation() {
-        // we use the same values as in polynomial evaluation test
-
-        let g2 = G2Projective::generator();
-
-        // y = 42 (it should be 42 regardless of x)
-        let coeffs = PublicCoefficients {
-            coefficients: vec![g2 * Scalar::from(42)],
-        };
-
-        assert_eq!(g2 * Scalar::from(42), coeffs.evaluate_at(&Scalar::from(1)));
-        assert_eq!(g2 * Scalar::from(42), coeffs.evaluate_at(&Scalar::from(0)));
-        assert_eq!(g2 * Scalar::from(42), coeffs.evaluate_at(&Scalar::from(10)));
-
-        // y = x + 10, at x = 2 (exp: 12)
-        let poly = PublicCoefficients {
-            coefficients: vec![g2 * Scalar::from(10), g2 * Scalar::from(1)],
-        };
-
-        assert_eq!(g2 * Scalar::from(12), poly.evaluate_at(&Scalar::from(2)));
-
-        // y = x^4 - 5x^2 + 2x - 3, at x = 3 (exp: 39)
-        let coeffs = PublicCoefficients {
-            coefficients: vec![
-                (-g2 * Scalar::from(3)),
-                g2 * Scalar::from(2),
-                (-g2 * Scalar::from(5)),
-                G2Projective::identity(),
-                g2 * Scalar::from(1),
-            ],
-        };
-
-        assert_eq!(g2 * Scalar::from(39), coeffs.evaluate_at(&Scalar::from(3)));
-
-        // empty coefficients
-        let coeffs = PublicCoefficients {
-            coefficients: Vec::new(),
-        };
-
-        // should always be 0
-        assert_eq!(
-            G2Projective::identity(),
-            coeffs.evaluate_at(&Scalar::from(1))
-        );
-        assert_eq!(
-            G2Projective::identity(),
-            coeffs.evaluate_at(&Scalar::from(0))
-        );
-        assert_eq!(
-            G2Projective::identity(),
-            coeffs.evaluate_at(&Scalar::from(10))
-        );
-    }
-
-    #[test]
-    fn public_coefficients_roundtrip() {
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-
-        let good = vec![
-            Polynomial::zero().public_coefficients(),
-            Polynomial::new_random(&mut rng, 0).public_coefficients(),
-            Polynomial::new_random(&mut rng, 1).public_coefficients(),
-            Polynomial::new_random(&mut rng, 4).public_coefficients(),
-            Polynomial::new_random(&mut rng, 15).public_coefficients(),
-        ];
-
-        for coefficient in good {
-            let bytes = coefficient.to_bytes();
-            let recovered = PublicCoefficients::try_from_bytes(&bytes).unwrap();
-            assert_eq!(coefficient, recovered);
-        }
-
-        assert!(PublicCoefficients::try_from_bytes(&[]).is_err());
-        assert!(PublicCoefficients::try_from_bytes(&[1]).is_err());
-        assert!(PublicCoefficients::try_from_bytes(&[1, 2, 3, 4]).is_err());
-
-        let g2 = G2Projective::generator().to_bytes();
-        let mut bad_length = Vec::new();
-        bad_length.extend_from_slice(&2u32.to_be_bytes());
-        bad_length.extend_from_slice(g2.as_ref());
-        assert!(PublicCoefficients::try_from_bytes(&bad_length).is_err());
-
-        let mut incomplete = Vec::new();
-        incomplete.extend_from_slice(&1u32.to_be_bytes());
-        incomplete.extend_from_slice(&g2.as_ref()[..95]);
-        assert!(PublicCoefficients::try_from_bytes(&incomplete).is_err());
-    }
-}

common/crypto/dkg/src/lib.rs

@@ -1,95 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-// forward-secure public key encryption scheme
-pub mod bte;
-pub mod error;
-pub mod interpolation;
-
-// this entire module is a big placeholder for whatever scheme we decide to use for the
-// secure channel encryption scheme, but I would assume that the top-level API would
-// remain more or less the same
-pub mod dealing;
-pub(crate) mod share;
-pub(crate) mod utils;
-
-pub use dealing::*;
-pub use share::*;
-
-// TODO: presumably this should live in a some different, common, crate?
-pub type Threshold = u64;
-pub type NodeIndex = u64;
-
-#[cfg(test)]
-mod tests {
-    use crate::interpolation::perform_lagrangian_interpolation_at_origin;
-    use crate::interpolation::polynomial::Polynomial;
-    use bls12_381::Scalar;
-    use rand_chacha::rand_core::SeedableRng;
-
-    #[test]
-    fn basic_dummy_secret_sharing() {
-        let degree = 2;
-
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-
-        let p1 = Polynomial::new_random(&mut rng, degree);
-        let p2 = Polynomial::new_random(&mut rng, degree);
-        let p3 = Polynomial::new_random(&mut rng, degree);
-        let p4 = Polynomial::new_random(&mut rng, degree);
-
-        let zero = Scalar::zero();
-        let one = Scalar::one();
-        let two = Scalar::from(2);
-        let three = Scalar::from(3);
-        let four = Scalar::from(4);
-
-        // i.e. given:
-        // p1 = a1 + x * b1 + ...
-        // p2 = a2 + x * b2 + ...
-        // ...
-        // expected = (a1 + a2 + ...) + x * (b1 + b2 + ...) + ...
-        // note: master polynomial is NEVER explicitly computed
-        let expected_master = &p1 + &p2 + &p3 + &p4;
-
-        let v1_secret = p1.evaluate_at(&one)
-            + p2.evaluate_at(&one)
-            + p3.evaluate_at(&one)
-            + p4.evaluate_at(&one);
-        let v2_secret = p1.evaluate_at(&two)
-            + p2.evaluate_at(&two)
-            + p3.evaluate_at(&two)
-            + p4.evaluate_at(&two);
-        let v3_secret = p1.evaluate_at(&three)
-            + p2.evaluate_at(&three)
-            + p3.evaluate_at(&three)
-            + p4.evaluate_at(&three);
-        let v4_secret = p1.evaluate_at(&four)
-            + p2.evaluate_at(&four)
-            + p3.evaluate_at(&four)
-            + p4.evaluate_at(&four);
-
-        // note that the following would have never happened in actual dkg setting, but it's
-        // used here mostly for a sanity check on the maths used
-        let samples = vec![
-            (one, v1_secret),
-            (two, v2_secret),
-            (three, v3_secret),
-            (four, v4_secret),
-        ];
-        let master_secret = perform_lagrangian_interpolation_at_origin(&samples).unwrap();
-
-        assert_eq!(expected_master.evaluate_at(&zero), master_secret);
-        assert_eq!(expected_master.evaluate_at(&one), v1_secret);
-        assert_eq!(expected_master.evaluate_at(&two), v2_secret);
-        assert_eq!(expected_master.evaluate_at(&three), v3_secret);
-        assert_eq!(expected_master.evaluate_at(&four), v4_secret);
-
-        // since we have 4 parties, but polynomials used are of degree 2, we only need at least 3
-        // issuers to contribute
-        let samples2 = vec![(one, v1_secret), (three, v3_secret), (four, v4_secret)];
-        let master_secret2 = perform_lagrangian_interpolation_at_origin(&samples2).unwrap();
-        assert_eq!(master_secret, master_secret2)
-    }
-}

common/crypto/dkg/src/share.rs

@@ -1,130 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::bte::{CHUNK_BYTES, NUM_CHUNKS, SCALAR_SIZE};
-use crate::error::DkgError;
-use crate::interpolation::perform_lagrangian_interpolation_at_origin;
-use crate::NodeIndex;
-use bls12_381::Scalar;
-use zeroize::Zeroize;
-
-// if this type is changed, one must ensure all values can fit in it
-pub type Chunk = u16;
-
-#[derive(PartialEq, Eq, Debug, Zeroize)]
-#[cfg_attr(test, derive(Clone))]
-#[zeroize(drop)]
-pub struct Share(pub(crate) Scalar);
-
-pub fn combine_shares(shares: Vec<Share>, node_indices: &[NodeIndex]) -> Result<Scalar, DkgError> {
-    if shares.len() != node_indices.len() {
-        return Err(DkgError::MismatchedLagrangianSamplesLengths {
-            x: node_indices.len(),
-            y: shares.len(),
-        });
-    }
-
-    let samples = shares
-        .into_iter()
-        .zip(node_indices.iter())
-        .map(|(share, index)| (Scalar::from(*index), share.0))
-        .collect::<Vec<_>>();
-
-    perform_lagrangian_interpolation_at_origin(&samples)
-}
-
-impl Share {
-    // not really used outside tests
-    #[cfg(test)]
-    pub(crate) fn random(mut rng: impl rand_core::RngCore) -> Self {
-        use ff::Field;
-        Share(Scalar::random(&mut rng))
-    }
-
-    pub(crate) fn to_chunks(&self) -> ChunkedShare {
-        let mut chunks = [0; NUM_CHUNKS];
-        let mut bytes = self.0.to_bytes();
-
-        for (chunk, chunk_bytes) in chunks.iter_mut().zip(bytes[..].chunks_exact(CHUNK_BYTES)) {
-            let mut tmp = [0u8; CHUNK_BYTES];
-            tmp.copy_from_slice(chunk_bytes);
-            *chunk = Chunk::from_le_bytes(tmp)
-        }
-
-        bytes.zeroize();
-        ChunkedShare { chunks }
-    }
-
-    pub(crate) fn inner(&self) -> &Scalar {
-        &self.0
-    }
-}
-
-impl From<Scalar> for Share {
-    fn from(s: Scalar) -> Self {
-        Share(s)
-    }
-}
-
-#[derive(Default, Zeroize)]
-#[cfg_attr(test, derive(Clone))]
-#[zeroize(drop)]
-pub(crate) struct ChunkedShare {
-    pub(crate) chunks: [Chunk; NUM_CHUNKS],
-}
-
-impl From<Share> for ChunkedShare {
-    fn from(share: Share) -> ChunkedShare {
-        share.to_chunks()
-    }
-}
-
-impl TryFrom<ChunkedShare> for Share {
-    type Error = DkgError;
-
-    fn try_from(chunked: ChunkedShare) -> Result<Share, Self::Error> {
-        let mut bytes = [0u8; SCALAR_SIZE];
-        for (chunk, chunk_bytes) in chunked
-            .chunks
-            .iter()
-            .zip(bytes[..].chunks_exact_mut(CHUNK_BYTES))
-        {
-            let tmp = chunk.to_le_bytes();
-            chunk_bytes.copy_from_slice(&tmp[..]);
-        }
-
-        let recovered = Option::from(Scalar::from_bytes(&bytes))
-            .map(Share)
-            .ok_or(DkgError::MalformedShare)?;
-
-        bytes.zeroize();
-        Ok(recovered)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::utils::combine_scalar_chunks;
-    use rand_core::SeedableRng;
-
-    #[test]
-    fn chunking_share() {
-        let dummy_seed = [1u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-
-        let share = Share::random(&mut rng);
-        let chunks: ChunkedShare = share.clone().into();
-
-        let scalar_chunks = chunks
-            .chunks
-            .iter()
-            .map(|c| Scalar::from(*c as u64))
-            .collect::<Vec<_>>();
-        let expected = combine_scalar_chunks(&scalar_chunks);
-        assert_eq!(expected, share.0);
-
-        let recombined: Share = chunks.try_into().unwrap();
-        assert_eq!(expected, recombined.0);
-    }
-}

common/crypto/dkg/src/todos.md

@@ -1,4 +0,0 @@
-Just a todo file to keep track of what should be changed
-
-- Deriving challenges and oracles should be more streamlined; perhaps some trait for hashing
-- perhaps there could be additional intermediate types in proofs of knowledge (for moves / responses / etc)

common/crypto/dkg/src/utils.rs

@@ -1,114 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::bte::CHUNK_SIZE;
-use bls12_381::hash_to_curve::{ExpandMsgXmd, HashToCurve, HashToField};
-use bls12_381::G1Projective;
-use bls12_381::{G2Projective, Scalar};
-use group::GroupEncoding;
-use sha2::{Digest, Sha256};
-
-#[macro_export]
-macro_rules! ensure_len {
-    ($a:expr, $b:expr) => {
-        if $a.len() != $b {
-            return false;
-        }
-    };
-}
-
-pub(crate) struct RandomOracleBuilder {
-    inner_state: Sha256,
-}
-
-impl RandomOracleBuilder {
-    pub(crate) fn new(domain: &[u8]) -> Self {
-        let mut inner_state = Sha256::new();
-        inner_state.update(domain);
-
-        RandomOracleBuilder { inner_state }
-    }
-
-    pub(crate) fn update(&mut self, data: impl AsRef<[u8]>) {
-        self.inner_state.update(data)
-    }
-
-    pub(crate) fn update_with_g1_elements<'a, I>(&mut self, items: I)
-    where
-        I: Iterator<Item = &'a G1Projective>,
-    {
-        items.for_each(|item| self.update(item.to_bytes()))
-    }
-
-    pub(crate) fn finalize(self) -> [u8; 32] {
-        self.inner_state.finalize().into()
-    }
-}
-
-// those will most likely need to somehow get re-combined with coconut (or maybe extracted to a completely different module)
-pub(crate) fn hash_to_scalar<M: AsRef<[u8]>>(msg: M, domain: &[u8]) -> Scalar {
-    // the unwrap here is fine as the result vector will have 1 element (as specified) and will not be empty
-    hash_to_scalars(msg, domain, 1).pop().unwrap()
-}
-
-pub(crate) fn hash_to_scalars<M: AsRef<[u8]>>(msg: M, domain: &[u8], n: usize) -> Vec<Scalar> {
-    let mut output = vec![Scalar::zero(); n];
-
-    Scalar::hash_to_field::<ExpandMsgXmd<Sha256>>(msg.as_ref(), domain, &mut output);
-    output
-}
-
-pub(crate) fn hash_g2<M: AsRef<[u8]>>(msg: M, domain: &[u8]) -> G2Projective {
-    <G2Projective as HashToCurve<ExpandMsgXmd<Sha256>>>::hash_to_curve(msg, domain)
-}
-
-pub(crate) fn combine_scalar_chunks(chunks: &[Scalar]) -> Scalar {
-    let chunk_size_scalar = Scalar::from(CHUNK_SIZE as u64);
-    chunks.iter().rev().fold(Scalar::zero(), |mut acc, chunk| {
-        acc *= chunk_size_scalar;
-        acc += chunk;
-        acc
-    })
-}
-
-pub(crate) fn combine_g1_chunks(chunks: &[G1Projective]) -> G1Projective {
-    let chunk_size_scalar = Scalar::from(CHUNK_SIZE as u64);
-    chunks
-        .iter()
-        .rev()
-        .fold(G1Projective::identity(), |mut acc, chunk| {
-            acc *= chunk_size_scalar;
-            acc += chunk;
-            acc
-        })
-}
-
-pub(crate) fn deserialize_scalar(b: &[u8]) -> Option<Scalar> {
-    if b.len() != 32 {
-        None
-    } else {
-        let mut repr: [u8; 32] = Default::default();
-        repr.as_mut().copy_from_slice(b);
-        Scalar::from_bytes(&repr).into()
-    }
-}
-
-pub(crate) fn deserialize_g1(b: &[u8]) -> Option<G1Projective> {
-    if b.len() != 48 {
-        None
-    } else {
-        let mut encoding = <G1Projective as GroupEncoding>::Repr::default();
-        encoding.as_mut().copy_from_slice(b);
-        G1Projective::from_bytes(&encoding).into()
-    }
-}
-
-pub(crate) fn deserialize_g2(b: &[u8]) -> Option<G2Projective> {
-    if b.len() != 96 {
-        None
-    } else {
-        let mut encoding = <G2Projective as GroupEncoding>::Repr::default();
-        encoding.as_mut().copy_from_slice(b);
-        G2Projective::from_bytes(&encoding).into()
-    }
-}

common/crypto/dkg/tests/integration.rs

@@ -1,285 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use bls12_381::{G2Projective, Scalar};
-use dkg::bte::{decrypt_share, keygen, setup, Epoch};
-use dkg::interpolation::perform_lagrangian_interpolation_at_origin;
-use dkg::{combine_shares, try_recover_verification_keys, Dealing};
-use rand_core::SeedableRng;
-use std::collections::BTreeMap;
-
-#[test]
-fn single_sender() {
-    // makes it easier to understand than `full_threshold_secret_sharing`
-    // and is a good stepping stone, because its everything each node will have to perform (from one point of view)
-
-    let dummy_seed = [42u8; 32];
-    let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-    let params = setup();
-
-    // the simplest possible case
-    let threshold = 2;
-
-    // the indices are going to get assigned externally, so for test sake, use non-consecutive ones
-    let node_indices = vec![15u64, 248, 33521];
-
-    let mut receivers = BTreeMap::new();
-    let mut full_keys = Vec::new();
-    for index in &node_indices {
-        let (dk, pk) = keygen(&params, &mut rng);
-        receivers.insert(*index, *pk.public_key());
-        full_keys.push((dk, pk))
-    }
-
-    // start off in a defined epoch (i.e. not root);
-    let epoch = Epoch::new(2);
-
-    // TODO: HERE BE SERIALIZATION / DESERIALIZATION THAT'S NOT IMPLEMENTED YET
-    // verify remote proofs of key possession
-    for key in full_keys.iter() {
-        assert!(key.1.verify());
-    }
-
-    let (dealing, dealer_share) = Dealing::create(
-        &mut rng,
-        &params,
-        node_indices[0],
-        threshold,
-        epoch,
-        &receivers,
-        None,
-    );
-    dealing
-        .verify(&params, epoch, threshold, &receivers, None)
-        .unwrap();
-
-    // make sure each share is actually decryptable (even though proofs say they must be, perform this sanity check)
-    for (i, (ref mut dk, _)) in full_keys.iter_mut().enumerate() {
-        dk.try_update_to(epoch, &params, &mut rng).unwrap();
-        let _recovered = decrypt_share(dk, i, &dealing.ciphertexts, epoch, None).unwrap();
-    }
-
-    // and for good measure, check that the dealer's share matches decryption result
-    let recovered_dealer =
-        decrypt_share(&full_keys[0].0, 0, &dealing.ciphertexts, epoch, None).unwrap();
-    assert_eq!(recovered_dealer, dealer_share.unwrap());
-}
-
-#[test]
-fn full_threshold_secret_sharing() {
-    let dummy_seed = [42u8; 32];
-    let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-    let params = setup();
-
-    // the simplest possible case
-    let threshold = 2;
-
-    // the indices are going to get assigned externally, so for test sake, use non-consecutive ones
-    let node_indices = vec![15u64, 248, 33521];
-
-    let mut receivers = BTreeMap::new();
-    let mut full_keys = Vec::new();
-    for index in &node_indices {
-        let (dk, pk) = keygen(&params, &mut rng);
-        receivers.insert(*index, *pk.public_key());
-        full_keys.push((dk, pk))
-    }
-
-    // start off in a defined epoch (i.e. not root);
-    let epoch = Epoch::new(2);
-
-    // TODO: HERE BE SERIALIZATION / DESERIALIZATION THAT'S NOT IMPLEMENTED YET
-    // verify remote proofs of key possession
-    for key in full_keys.iter() {
-        assert!(key.1.verify());
-    }
-
-    let dealings = node_indices
-        .iter()
-        .map(|&dealer_index| {
-            Dealing::create(
-                &mut rng,
-                &params,
-                dealer_index,
-                threshold,
-                epoch,
-                &receivers,
-                None,
-            )
-            .0
-        })
-        .collect::<Vec<_>>();
-    for dealing in dealings.iter() {
-        dealing
-            .verify(&params, epoch, threshold, &receivers, None)
-            .unwrap();
-    }
-
-    // recover verification keys
-    let (recovered_master, recovered_partials) =
-        try_recover_verification_keys(&dealings, threshold, &receivers).unwrap();
-
-    let g2 = G2Projective::generator();
-
-    let mut derived_secrets = Vec::new();
-    for (i, (ref mut dk, _)) in full_keys.iter_mut().enumerate() {
-        dk.try_update_to(epoch, &params, &mut rng).unwrap();
-
-        let shares = dealings
-            .iter()
-            .map(|dealing| decrypt_share(dk, i, &dealing.ciphertexts, epoch, None).unwrap())
-            .collect();
-
-        // we know dealer_share matches, but it would be inconvenient to try to put them in here,
-        // so for ease of use (IN A TEST SETTING), just decrypt one's own share
-        let recovered_secret =
-            combine_shares(shares, &receivers.keys().copied().collect::<Vec<_>>()).unwrap();
-
-        // make sure it matches the associated vk
-        assert_eq!(recovered_partials[i], g2 * recovered_secret);
-
-        derived_secrets.push(recovered_secret)
-    }
-
-    // sanity check that the shares were combined correctly and if we take threshold number of them,
-    // we end up with the same master secret, note: those are NEVER explicitly recovered in actual system
-    // (remember threshold was 2)
-    let master1 = perform_lagrangian_interpolation_at_origin(&[
-        (Scalar::from(node_indices[0]), derived_secrets[0]),
-        (Scalar::from(node_indices[1]), derived_secrets[1]),
-    ])
-    .unwrap();
-
-    let master2 = perform_lagrangian_interpolation_at_origin(&[
-        (Scalar::from(node_indices[1]), derived_secrets[1]),
-        (Scalar::from(node_indices[2]), derived_secrets[2]),
-    ])
-    .unwrap();
-
-    assert_eq!(master1, master2);
-    assert_eq!(recovered_master, g2 * master1);
-}
-
-#[test]
-fn full_threshold_secret_resharing() {
-    let dummy_seed = [42u8; 32];
-    let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-    let params = setup();
-
-    // the simplest possible case
-    let threshold = 2;
-
-    // the indices are going to get assigned externally, so for test sake, use non-consecutive ones
-    let node_indices = vec![15u64, 248, 33521];
-
-    let mut receivers = BTreeMap::new();
-    let mut full_keys = Vec::new();
-    for index in &node_indices {
-        let (dk, pk) = keygen(&params, &mut rng);
-        receivers.insert(*index, *pk.public_key());
-        full_keys.push((dk, pk))
-    }
-
-    // start off in a defined epoch (i.e. not root);
-    let epoch = Epoch::new(2);
-
-    let first_dealings = node_indices
-        .iter()
-        .map(|&dealer_index| {
-            Dealing::create(
-                &mut rng,
-                &params,
-                dealer_index,
-                threshold,
-                epoch,
-                &receivers,
-                None,
-            )
-            .0
-        })
-        .collect::<Vec<_>>();
-
-    // recover verification keys
-    let (public_original_master, recovered_partials) =
-        try_recover_verification_keys(&first_dealings, threshold, &receivers).unwrap();
-
-    let mut derived_secrets = Vec::new();
-    for (i, (ref mut dk, _)) in full_keys.iter_mut().enumerate() {
-        dk.try_update_to(epoch, &params, &mut rng).unwrap();
-
-        let shares = first_dealings
-            .iter()
-            .map(|dealing| decrypt_share(dk, i, &dealing.ciphertexts, epoch, None).unwrap())
-            .collect();
-
-        let recovered_secret =
-            combine_shares(shares, &receivers.keys().copied().collect::<Vec<_>>()).unwrap();
-
-        derived_secrets.push(recovered_secret)
-    }
-
-    let original_master = perform_lagrangian_interpolation_at_origin(&[
-        (Scalar::from(node_indices[0]), derived_secrets[0]),
-        (Scalar::from(node_indices[1]), derived_secrets[1]),
-    ])
-    .unwrap();
-
-    let next_epoch = Epoch::new(3);
-
-    // attempt to create resharing dealings!
-    let resharing_dealings = node_indices
-        .iter()
-        .zip(derived_secrets.iter())
-        .map(|(&dealer_index, prior_secret)| {
-            Dealing::create(
-                &mut rng,
-                &params,
-                dealer_index,
-                threshold,
-                next_epoch,
-                &receivers,
-                Some(*prior_secret),
-            )
-            .0
-        })
-        .collect::<Vec<_>>();
-
-    for (reshared_dealing, prior_vk) in resharing_dealings.iter().zip(recovered_partials.iter()) {
-        reshared_dealing
-            .verify(&params, next_epoch, threshold, &receivers, Some(*prior_vk))
-            .unwrap();
-    }
-
-    // recover verification keys
-    let (public_reshared_master, reshared_partials) =
-        try_recover_verification_keys(&resharing_dealings, threshold, &receivers).unwrap();
-
-    let mut reshared_secrets = Vec::new();
-    for (i, (ref mut dk, _)) in full_keys.iter_mut().enumerate() {
-        dk.try_update_to(next_epoch, &params, &mut rng).unwrap();
-
-        let shares = resharing_dealings
-            .iter()
-            .map(|dealing| decrypt_share(dk, i, &dealing.ciphertexts, next_epoch, None).unwrap())
-            .collect();
-
-        let recovered_secret =
-            combine_shares(shares, &receivers.keys().copied().collect::<Vec<_>>()).unwrap();
-
-        reshared_secrets.push(recovered_secret)
-    }
-
-    let reshared_master = perform_lagrangian_interpolation_at_origin(&[
-        (Scalar::from(node_indices[0]), reshared_secrets[0]),
-        (Scalar::from(node_indices[1]), reshared_secrets[1]),
-    ])
-    .unwrap();
-
-    // the master secret and public values didn't change
-    assert_eq!(original_master, reshared_master);
-    assert_eq!(public_original_master, public_reshared_master);
-
-    // but partials did
-    assert_ne!(derived_secrets, reshared_secrets);
-    assert_ne!(recovered_partials, reshared_partials);
-}

common/network-defaults/src/mainnet.rs

@@ -21,6 +21,12 @@ pub(crate) const REWARDING_VALIDATOR_ADDRESS: &str = "n10yyd98e2tuwu0f7ypz9dy3hh
 pub(crate) fn validators() -> Vec<ValidatorDetails> {
     vec![ValidatorDetails::new(
         "https://rpc.nyx.nodes.guru/",
-        Some("https://validator.nymtech.net/api"),
+        Some("https://api.nyx.nodes.guru/"),
+    ), ValidatorDetails::new(
+        "https://test2.nyx.nodes.guru/",
+        Some("https://test1.nyx.nodes.guru/"),
+    ), ValidatorDetails::new(
+        "https://test2.nyx.nodes.guru/",
+        Some("https://test1.nyx.nodes.guru/"),
     )]
 }

contracts/Cargo.lock

@@ -41,7 +41,7 @@ checksum = "f771a5d1f5503f7f4279a30f3643d3421ba149848b89ecaaec0ea2acf04a5ac4"
 
 [[package]]
 name = "bandwidth-claim"
-version = "1.0.0-rc.2"
+version = "1.0.0-rc.1"
 dependencies = [
  "bandwidth-claim-contract",
  "config",
@@ -144,12 +144,6 @@ version = "1.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
 
-[[package]]
-name = "bytes"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4872d67bab6358e59559027aa3b9157c53d9358c51423c17554809a8858e0f8"
-
 [[package]]
 name = "cc"
 version = "1.0.72"
@@ -206,9 +200,6 @@ dependencies = [
  "config",
  "cosmwasm-std",
  "cosmwasm-storage",
- "cw-controllers",
- "cw-multi-test",
- "cw-storage-plus",
  "schemars",
  "serde",
  "thiserror",
@@ -218,7 +209,6 @@ dependencies = [
 name = "coconut-bandwidth-contract-common"
 version = "0.1.0"
 dependencies = [
- "cosmwasm-std",
  "schemars",
  "serde",
 ]
@@ -251,9 +241,9 @@ dependencies = [
 
 [[package]]
 name = "cosmwasm-crypto"
-version = "1.0.0-beta8"
+version = "1.0.0-beta7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37e70111e9701c3ec43bfbff0e523cd4cb115876b4d3433813436dd0934ee962"
+checksum = "88c2565b1e73a816fb659ef4838fc356143fbd35f43c48a51d2d7d4e5d6679d3"
 dependencies = [
  "digest 0.9.0",
  "ed25519-zebra",
@@ -264,18 +254,18 @@ dependencies = [
 
 [[package]]
 name = "cosmwasm-derive"
-version = "1.0.0-beta8"
+version = "1.0.0-beta7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58bc2ad5d86be5f6068833f63e20786768db6890019c095dd7775232184fb7b3"
+checksum = "fa89fcdf8dbbe0088e663d0a814aa7368e7ebe8fb045a3a150fb5fdc2ffe3b45"
 dependencies = [
  "syn",
 ]
 
 [[package]]
 name = "cosmwasm-schema"
-version = "1.0.0-beta7"
+version = "1.0.0-beta3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "63f79866e7b2190b6b6cb06959e308183c8d9511a8530f7292073f3cddc963db"
+checksum = "818b928263c09a3269c2bed22494a62107a43ef87900e273af8ad2cb9f7e4440"
 dependencies = [
  "schemars",
  "serde_json",
@@ -283,9 +273,9 @@ dependencies = [
 
 [[package]]
 name = "cosmwasm-std"
-version = "1.0.0-beta8"
+version = "1.0.0-beta7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "915ca82bd944f116f3a9717481f3fa657e4a73f28c4887288761ebb24e6fbe10"
+checksum = "bcb8f99a61d0b9069e1afc80a4ffea87dcc3523edd992080923870b13a677da0"
 dependencies = [
  "base64",
  "cosmwasm-crypto",
@@ -300,9 +290,9 @@ dependencies = [
 
 [[package]]
 name = "cosmwasm-storage"
-version = "1.0.0-beta8"
+version = "1.0.0-beta7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c4be9fd8c9d3ae7d0c32a925ecbc20707007ce0cba1f7538c0d78b7a2d3729b"
+checksum = "07f856099c824aa8f2488e62d1da3fc06383d3fdbc764573595f451be43441a2"
 dependencies = [
  "cosmwasm-std",
  "serde",
@@ -391,149 +381,17 @@ dependencies = [
  "zeroize",
 ]
 
-[[package]]
-name = "cw-controllers"
-version = "0.13.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bc6d042b14823b0e9f33f5cdd67a1eb9b16a7d79f7547b1a73c8870b518b97b"
-dependencies = [
- "cosmwasm-std",
- "cw-storage-plus",
- "cw-utils",
- "schemars",
- "serde",
- "thiserror",
-]
-
-[[package]]
-name = "cw-multi-test"
-version = "0.13.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cbea57e5be4a682268a5eca1a57efece57a54ff216bfd87603d5e864aad40e12"
-dependencies = [
- "anyhow",
- "cosmwasm-std",
- "cosmwasm-storage",
- "cw-storage-plus",
- "cw-utils",
- "derivative",
- "itertools",
- "prost",
- "schemars",
- "serde",
- "thiserror",
-]
-
 [[package]]
 name = "cw-storage-plus"
-version = "0.13.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9336ecef1e19d56cf6e3e932475fc6a3dee35eec5a386e07917a1d1ba6bb0e35"
-dependencies = [
- "cosmwasm-std",
- "schemars",
- "serde",
-]
-
-[[package]]
-name = "cw-utils"
-version = "0.13.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "babd2c090f39d07ce5bf2556962305e795daa048ce20a93709eb591476e4a29e"
-dependencies = [
- "cosmwasm-std",
- "schemars",
- "serde",
- "thiserror",
-]
-
-[[package]]
-name = "cw2"
 version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d686da2d2b3b646bea15d448dc25c3e132097a7c40ef9ba7b4db741375b6181f"
+checksum = "5e8b7f9a758c030d375520df947323c052704f784561fc28dcaab4f988c50a30"
 dependencies = [
  "cosmwasm-std",
- "cw-storage-plus",
  "schemars",
  "serde",
 ]
 
-[[package]]
-name = "cw3"
-version = "0.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b7c7a87aed0637432c9ec39a691e533e18006dd400c67bce9f0ad643de7d52c"
-dependencies = [
- "cosmwasm-std",
- "cw-utils",
- "schemars",
- "serde",
-]
-
-[[package]]
-name = "cw3-fixed-multisig"
-version = "0.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "666afbb3bcaefc697047a0be8c4c5015be053a8456d27dd26e0b8ab114f6f5dd"
-dependencies = [
- "cosmwasm-std",
- "cw-storage-plus",
- "cw-utils",
- "cw2",
- "cw3",
- "schemars",
- "serde",
- "thiserror",
-]
-
-[[package]]
-name = "cw3-flex-multisig"
-version = "0.13.1"
-dependencies = [
- "cosmwasm-schema",
- "cosmwasm-std",
- "cw-multi-test",
- "cw-storage-plus",
- "cw-utils",
- "cw2",
- "cw3",
- "cw3-fixed-multisig",
- "cw4",
- "cw4-group",
- "schemars",
- "serde",
- "thiserror",
-]
-
-[[package]]
-name = "cw4"
-version = "0.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51d51b6e05094bfb91029f5baf5d1f39ee10f16fd61f8bf0e6f6632a5dbfb7f9"
-dependencies = [
- "cosmwasm-std",
- "cw-storage-plus",
- "schemars",
- "serde",
-]
-
-[[package]]
-name = "cw4-group"
-version = "0.13.1"
-dependencies = [
- "cosmwasm-schema",
- "cosmwasm-std",
- "cw-controllers",
- "cw-storage-plus",
- "cw-utils",
- "cw2",
- "cw4",
- "schemars",
- "serde",
- "thiserror",
-]
-
 [[package]]
 name = "der"
 version = "0.4.5"
@@ -543,17 +401,6 @@ dependencies = [
  "const-oid",
 ]
 
-[[package]]
-name = "derivative"
-version = "2.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "digest"
 version = "0.8.1"
@@ -628,12 +475,6 @@ dependencies = [
  "zeroize",
 ]
 
-[[package]]
-name = "either"
-version = "1.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
-
 [[package]]
 name = "elliptic-curve"
 version = "0.10.6"
@@ -873,15 +714,6 @@ dependencies = [
  "unicode-normalization",
 ]
 
-[[package]]
-name = "itertools"
-version = "0.10.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9a9d19fa1e79b6215ff29b9d6880b706147f16e9b1dbb1e4e5947b5b02bc5e3"
-dependencies = [
- "either",
-]
-
 [[package]]
 name = "itoa"
 version = "1.0.1"
@@ -1229,29 +1061,6 @@ dependencies = [
  "unicode-xid",
 ]
 
-[[package]]
-name = "prost"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "444879275cb4fd84958b1a1d5420d15e6fcf7c235fe47f053c9c2a80aceb6001"
-dependencies = [
- "bytes",
- "prost-derive",
-]
-
-[[package]]
-name = "prost-derive"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9cc1a3263e07e0bf68e96268f37665207b49560d98739662cdfaae215c720fe"
-dependencies = [
- "anyhow",
- "itertools",
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "quick-error"
 version = "2.0.1"
@@ -1658,9 +1467,9 @@ checksum = "56dee185309b50d1f11bfedef0fe6d036842e3fb77413abef29f8f8d1c5d4c1c"
 
 [[package]]
 name = "uint"
-version = "0.9.3"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12f03af7ccf01dd611cc450a0d10dbc9b745770d096473e2faf0ca6e2d66d1e0"
+checksum = "6470ab50f482bde894a037a57064480a246dbfdd5960bd65a44824693f08da5f"
 dependencies = [
  "byteorder",
  "crunchy",

contracts/Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-members = ["bandwidth-claim", "coconut-bandwidth", "mixnet", "vesting", "multisig/cw3-flex-multisig", "multisig/cw4-group"]
+members = ["bandwidth-claim", "coconut-bandwidth", "mixnet", "vesting"]
 
 [profile.release]
 opt-level = 3

contracts/bandwidth-claim/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bandwidth-claim"
-version = "1.0.0-rc.2"
+version = "1.0.0-rc.1"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -14,8 +14,8 @@ config = { path = "../../common/config"}
 [dependencies]
 bandwidth-claim-contract = { path = "../../common/bandwidth-claim-contract" }
 
-cosmwasm-std = "1.0.0-beta8"
-cosmwasm-storage = "1.0.0-beta8"
+cosmwasm-std = "1.0.0-beta6"
+cosmwasm-storage = "1.0.0-beta6"
 
 schemars = "0.8"
 serde = { version = "1.0.103", default-features = false, features = ["derive"] }

contracts/coconut-bandwidth/Cargo.toml

@@ -13,14 +13,9 @@ bandwidth-claim-contract = { path = "../../common/bandwidth-claim-contract" }
 coconut-bandwidth-contract-common = { path = "../../common/cosmwasm-smart-contracts/coconut-bandwidth-contract" }
 config = { path = "../../common/config"}
 
-cosmwasm-std = "1.0.0-beta8"
-cosmwasm-storage = "1.0.0-beta8"
-cw-storage-plus = "0.13.2"
-cw-controllers = "0.13.2"
+cosmwasm-std = "1.0.0-beta3"
+cosmwasm-storage = "1.0.0-beta3"
 
 schemars = "0.8"
 serde = { version = "1.0.103", default-features = false, features = ["derive"] }
 thiserror = "1.0.23"
-
-[dev-dependencies]
-cw-multi-test = { version = "0.13.2" }

contracts/coconut-bandwidth/src/contract.rs

@@ -1,163 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use cosmwasm_std::{entry_point, Binary, Deps, DepsMut, Env, MessageInfo, Response, StdResult};
-
-use coconut_bandwidth_contract_common::msg::{ExecuteMsg, InstantiateMsg, MigrateMsg, QueryMsg};
-
-use crate::error::ContractError;
-use crate::state::{Config, ADMIN, CONFIG};
-use crate::transactions;
-
-/// Instantiate the contract.
-///
-/// `deps` contains Storage, API and Querier
-/// `msg` is the contract initialization message, sort of like a constructor call.
-#[entry_point]
-pub fn instantiate(
-    mut deps: DepsMut<'_>,
-    _env: Env,
-    _info: MessageInfo,
-    msg: InstantiateMsg,
-) -> Result<Response, ContractError> {
-    let multisig_addr = deps.api.addr_validate(&msg.multisig_addr)?;
-    let pool_addr = deps.api.addr_validate(&msg.pool_addr)?;
-
-    ADMIN.set(deps.branch(), Some(multisig_addr.clone()))?;
-
-    let cfg = Config {
-        multisig_addr,
-        pool_addr,
-    };
-    CONFIG.save(deps.storage, &cfg)?;
-
-    Ok(Response::default())
-}
-
-/// Handle an incoming message
-#[entry_point]
-pub fn execute(
-    deps: DepsMut<'_>,
-    env: Env,
-    info: MessageInfo,
-    msg: ExecuteMsg,
-) -> Result<Response, ContractError> {
-    match msg {
-        ExecuteMsg::DepositFunds { data } => transactions::deposit_funds(deps, env, info, data),
-        ExecuteMsg::ReleaseFunds { funds } => transactions::release_funds(deps, env, info, funds),
-    }
-}
-
-#[entry_point]
-pub fn query(_deps: Deps, _env: Env, _msg: QueryMsg) -> StdResult<Binary> {
-    unimplemented!();
-}
-
-#[entry_point]
-pub fn migrate(_deps: DepsMut<'_>, _env: Env, _msg: MigrateMsg) -> Result<Response, ContractError> {
-    Ok(Default::default())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::support::tests::helpers::*;
-    use coconut_bandwidth_contract_common::deposit::DepositData;
-    use config::defaults::DENOM;
-    use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};
-    use cosmwasm_std::{coins, Addr};
-    use cw_multi_test::Executor;
-    use serde::de::Unexpected::Str;
-
-    #[test]
-    fn initialize_contract() {
-        let mut deps = mock_dependencies();
-        let env = mock_env();
-        let msg = InstantiateMsg {
-            multisig_addr: String::from(MULTISIG_CONTRACT),
-            pool_addr: String::from(POOL_CONTRACT),
-        };
-        let info = mock_info("creator", &[]);
-
-        let res = instantiate(deps.as_mut(), env.clone(), info, msg).unwrap();
-        assert_eq!(0, res.messages.len());
-
-        // Contract balance should be 0
-        assert_eq!(
-            coins(0, DENOM),
-            vec![deps
-                .as_ref()
-                .querier
-                .query_balance(env.contract.address, DENOM)
-                .unwrap()]
-        );
-    }
-
-    #[test]
-    fn deposit_and_release() {
-        let init_funds = coins(10, DENOM);
-        let deposit_funds = coins(1, DENOM);
-        let release_funds = coins(2, DENOM);
-        let mut app = mock_app(&init_funds);
-        let multisig_addr = String::from(MULTISIG_CONTRACT);
-        let pool_addr = String::from(POOL_CONTRACT);
-
-        let code_id = app.store_code(contract_bandwidth());
-        let msg = InstantiateMsg {
-            multisig_addr: multisig_addr.clone(),
-            pool_addr: pool_addr.clone(),
-        };
-        let contract_addr = app
-            .instantiate_contract(
-                code_id,
-                Addr::unchecked(OWNER),
-                &msg,
-                &[],
-                "bandwidth",
-                None,
-            )
-            .unwrap();
-
-        let msg = ExecuteMsg::DepositFunds {
-            data: DepositData::new(
-                String::from("info"),
-                String::from("id"),
-                String::from("enc"),
-            ),
-        };
-        app.execute_contract(
-            Addr::unchecked(OWNER),
-            contract_addr.clone(),
-            &msg,
-            &deposit_funds,
-        )
-        .unwrap();
-
-        // try to release more then it's in the contract
-        let msg = ExecuteMsg::ReleaseFunds {
-            funds: release_funds[0].clone(),
-        };
-        let err = app
-            .execute_contract(
-                Addr::unchecked(multisig_addr.clone()),
-                contract_addr.clone(),
-                &msg,
-                &[],
-            )
-            .unwrap_err();
-        assert_eq!(ContractError::NotEnoughFunds, err.downcast().unwrap());
-
-        let msg = ExecuteMsg::ReleaseFunds {
-            funds: deposit_funds[0].clone(),
-        };
-        app.execute_contract(
-            Addr::unchecked(multisig_addr),
-            contract_addr.clone(),
-            &msg,
-            &[],
-        )
-        .unwrap();
-        let pool_bal = app.wrap().query_balance(pool_addr, DENOM).unwrap();
-        assert_eq!(pool_bal, deposit_funds[0]);
-    }
-}

contracts/coconut-bandwidth/src/error.rs

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use cosmwasm_std::StdError;
-use cw_controllers::AdminError;
 use thiserror::Error;
 
 use config::defaults::DENOM;
@@ -24,10 +23,4 @@ pub enum ContractError {
 
     #[error("Wrong coin denomination, you must send {}", DENOM)]
     WrongDenom,
-
-    #[error("There aren't enough funds in the contract")]
-    NotEnoughFunds,
-
-    #[error("{0}")]
-    Admin(#[from] AdminError),
 }

contracts/coconut-bandwidth/src/lib.rs

@@ -1,8 +1,73 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-pub mod contract;
 mod error;
-mod state;
 mod support;
 mod transactions;
+
+use cosmwasm_std::{entry_point, DepsMut, Env, MessageInfo, Response};
+
+use crate::error::ContractError;
+use coconut_bandwidth_contract_common::msg::{ExecuteMsg, InstantiateMsg, MigrateMsg};
+
+/// Instantiate the contract.
+///
+/// `deps` contains Storage, API and Querier
+/// `env` contains block, message and contract info
+/// `msg` is the contract initialization message, sort of like a constructor call.
+#[entry_point]
+pub fn instantiate(
+    _deps: DepsMut<'_>,
+    _env: Env,
+    _info: MessageInfo,
+    _msg: InstantiateMsg,
+) -> Result<Response, ContractError> {
+    Ok(Response::default())
+}
+
+/// Handle an incoming message
+#[entry_point]
+pub fn execute(
+    deps: DepsMut<'_>,
+    env: Env,
+    info: MessageInfo,
+    msg: ExecuteMsg,
+) -> Result<Response, ContractError> {
+    match msg {
+        ExecuteMsg::DepositFunds { data } => transactions::deposit_funds(deps, env, info, data),
+    }
+}
+
+#[entry_point]
+pub fn migrate(_deps: DepsMut<'_>, _env: Env, _msg: MigrateMsg) -> Result<Response, ContractError> {
+    Ok(Default::default())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use config::defaults::DENOM;
+    use cosmwasm_std::coins;
+    use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};
+
+    #[test]
+    fn initialize_contract() {
+        let mut deps = mock_dependencies();
+        let env = mock_env();
+        let msg = InstantiateMsg {};
+        let info = mock_info("creator", &[]);
+
+        let res = instantiate(deps.as_mut(), env.clone(), info, msg).unwrap();
+        assert_eq!(0, res.messages.len());
+
+        // Contract balance should be 0
+        assert_eq!(
+            coins(0, DENOM),
+            vec![deps
+                .as_ref()
+                .querier
+                .query_balance(env.contract.address, DENOM)
+                .unwrap()]
+        );
+    }
+}

contracts/coconut-bandwidth/src/state.rs

@@ -1,18 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use cosmwasm_std::Addr;
-use cw_controllers::Admin;
-use cw_storage_plus::Item;
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-
-pub const ADMIN: Admin = Admin::new("admin");
-
-#[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema, Debug)]
-pub struct Config {
-    pub multisig_addr: Addr,
-    pub pool_addr: Addr,
-}
-
-pub const CONFIG: Item<Config> = Item::new("config");

contracts/coconut-bandwidth/src/support/tests.rs

@@ -3,44 +3,17 @@
 
 #[cfg(test)]
 pub mod helpers {
-    pub const OWNER: &str = "admin0001";
-    pub const SOMEBODY: &str = "somebody";
-    pub const MULTISIG_CONTRACT: &str = "multisig contract address";
-    pub const POOL_CONTRACT: &str = "mix pool contract address";
-
-    use crate::contract::instantiate;
+    use crate::instantiate;
     use coconut_bandwidth_contract_common::msg::InstantiateMsg;
     use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info, MockApi, MockQuerier};
-    use cosmwasm_std::{Addr, Coin, Empty, MemoryStorage, OwnedDeps};
-    use cw_multi_test::{App, AppBuilder, Contract, ContractWrapper};
+    use cosmwasm_std::{Empty, MemoryStorage, OwnedDeps};
 
     pub fn init_contract() -> OwnedDeps<MemoryStorage, MockApi, MockQuerier<Empty>> {
         let mut deps = mock_dependencies();
-        let msg = InstantiateMsg {
-            multisig_addr: String::from(MULTISIG_CONTRACT),
-            pool_addr: String::from(POOL_CONTRACT),
-        };
+        let msg = InstantiateMsg {};
         let env = mock_env();
         let info = mock_info("creator", &[]);
         instantiate(deps.as_mut(), env.clone(), info, msg).unwrap();
         return deps;
     }
-
-    pub fn mock_app(init_funds: &[Coin]) -> App {
-        AppBuilder::new().build(|router, _, storage| {
-            router
-                .bank
-                .init_balance(storage, &Addr::unchecked(OWNER), init_funds.to_vec())
-                .unwrap();
-        })
-    }
-
-    pub fn contract_bandwidth() -> Box<dyn Contract<Empty>> {
-        let contract = ContractWrapper::new(
-            crate::contract::execute,
-            crate::contract::instantiate,
-            crate::contract::query,
-        );
-        Box::new(contract)
-    }
 }

contracts/coconut-bandwidth/src/transactions.rs

@@ -1,11 +1,9 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use cosmwasm_std::{BankMsg, Coin, DepsMut, Env, Event, MessageInfo, Response};
+use cosmwasm_std::{DepsMut, Env, Event, MessageInfo, Response};
 
 use crate::error::ContractError;
-use crate::state::{ADMIN, CONFIG};
-
 use coconut_bandwidth_contract_common::deposit::DepositData;
 use coconut_bandwidth_contract_common::events::{
     DEPOSITED_FUNDS_EVENT_TYPE, DEPOSIT_ENCRYPTION_KEY, DEPOSIT_IDENTITY_KEY, DEPOSIT_INFO,
@@ -39,40 +37,12 @@ pub(crate) fn deposit_funds(
     Ok(Response::new().add_event(event))
 }
 
-pub(crate) fn release_funds(
-    deps: DepsMut<'_>,
-    env: Env,
-    info: MessageInfo,
-    funds: Coin,
-) -> Result<Response, ContractError> {
-    if funds.denom != DENOM {
-        return Err(ContractError::WrongDenom);
-    }
-    let current_balance = deps.querier.query_balance(env.contract.address, DENOM)?;
-    if funds.amount > current_balance.amount {
-        return Err(ContractError::NotEnoughFunds);
-    }
-    ADMIN.assert_admin(deps.as_ref(), &info.sender)?;
-
-    let cfg = CONFIG.load(deps.storage)?;
-
-    let return_tokens = BankMsg::Send {
-        to_address: cfg.pool_addr.into(),
-        amount: vec![funds],
-    };
-    let response = Response::new().add_message(return_tokens);
-
-    Ok(response)
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::support::tests::helpers;
-    use crate::support::tests::helpers::{MULTISIG_CONTRACT, POOL_CONTRACT};
     use cosmwasm_std::testing::{mock_env, mock_info};
-    use cosmwasm_std::{Coin, CosmosMsg};
-    use cw_controllers::AdminError;
+    use cosmwasm_std::Coin;
 
     #[test]
     fn invalid_deposit() {
@@ -163,65 +133,4 @@ mod tests {
             .unwrap();
         assert_eq!(encryption_key_attr.value, encryption_key);
     }
-
-    #[test]
-    fn invalid_release() {
-        let mut deps = helpers::init_contract();
-        let env = mock_env();
-        let invalid_admin = "invalid admin";
-        let funds = Coin::new(1, DENOM);
-
-        let err = release_funds(
-            deps.as_mut(),
-            env.clone(),
-            mock_info(invalid_admin, &[]),
-            Coin::new(1, "invalid denom"),
-        )
-        .unwrap_err();
-        assert_eq!(err, ContractError::WrongDenom);
-
-        let err = release_funds(
-            deps.as_mut(),
-            env.clone(),
-            mock_info(invalid_admin, &[]),
-            funds.clone(),
-        )
-        .unwrap_err();
-        assert_eq!(err, ContractError::NotEnoughFunds);
-
-        deps.querier
-            .update_balance(env.contract.address.clone(), vec![funds.clone()]);
-        let err = release_funds(
-            deps.as_mut(),
-            env.clone(),
-            mock_info(invalid_admin, &[]),
-            funds.clone(),
-        )
-        .unwrap_err();
-        assert_eq!(err, ContractError::Admin(AdminError::NotAdmin {}));
-    }
-
-    #[test]
-    fn valid_release() {
-        let mut deps = helpers::init_contract();
-        let env = mock_env();
-        let coin = Coin::new(1, DENOM);
-
-        deps.querier
-            .update_balance(env.contract.address.clone(), vec![coin.clone()]);
-        let res = release_funds(
-            deps.as_mut(),
-            env,
-            mock_info(MULTISIG_CONTRACT, &[]),
-            coin.clone(),
-        )
-        .unwrap();
-        assert_eq!(
-            res.messages[0].msg,
-            CosmosMsg::Bank(BankMsg::Send {
-                to_address: String::from(POOL_CONTRACT),
-                amount: vec![coin]
-            })
-        );
-    }
 }

contracts/mixnet/Cargo.toml

@@ -20,9 +20,9 @@ mixnet-contract-common = { path = "../../common/cosmwasm-smart-contracts/mixnet-
 vesting-contract-common = { path = "../../common/cosmwasm-smart-contracts/vesting-contract" }
 config = { path = "../../common/config"}
 
-cosmwasm-std = "1.0.0-beta8"
-cosmwasm-storage = "1.0.0-beta8"
-cw-storage-plus = "0.13.2"
+cosmwasm-std = "1.0.0-beta6"
+cosmwasm-storage = "1.0.0-beta6"
+cw-storage-plus = "0.13.1"
 
 az = "1.2.0"
 bs58 = "0.4.0"

contracts/mixnet/src/contract.rs

@@ -7,7 +7,6 @@ use crate::delegations::queries::query_mixnode_delegation;
 use crate::delegations::queries::{
     query_mixnode_delegations_paged, query_pending_delegation_events,
 };
-use crate::delegations::storage::delegations;
 use crate::error::ContractError;
 use crate::gateways::queries::query_gateways_paged;
 use crate::gateways::queries::query_owns_gateway;
@@ -33,7 +32,6 @@ use crate::rewards::storage as rewards_storage;
 use cosmwasm_std::{
     entry_point, to_binary, Addr, Deps, DepsMut, Env, MessageInfo, QueryResponse, Response, Uint128,
 };
-use mixnet_contract_common::mixnode::DelegationEvent;
 use mixnet_contract_common::{
     ContractStateParams, ExecuteMsg, InstantiateMsg, MigrateMsg, QueryMsg,
 };
@@ -366,21 +364,14 @@ pub fn query(deps: Deps<'_>, env: Env, msg: QueryMsg) -> Result<QueryResponse, C
         QueryMsg::QueryDelegatorReward {
             address,
             mix_identity,
-            proxy,
         } => to_binary(&crate::rewards::queries::query_delegator_reward(
             deps,
             address,
             mix_identity,
-            proxy,
-        )?),
-        QueryMsg::GetPendingDelegationEvents {
-            owner_address,
-            proxy_address,
-        } => to_binary(&query_pending_delegation_events(
-            deps,
-            owner_address,
-            proxy_address,
         )?),
+        QueryMsg::GetPendingDelegationEvents { owner_address } => to_binary(
+            &query_pending_delegation_events(deps.storage, owner_address)?,
+        ),
         QueryMsg::GetAllDelegationKeys {} => to_binary(
             &crate::delegations::queries::query_all_delegation_keys(deps.storage)?,
         ),
@@ -393,35 +384,7 @@ pub fn query(deps: Deps<'_>, env: Env, msg: QueryMsg) -> Result<QueryResponse, C
 }
 
 #[entry_point]
-pub fn migrate(deps: DepsMut<'_>, _env: Env, _msg: MigrateMsg) -> Result<Response, ContractError> {
-    // if there exists any delegation of 0 value, remove it
-    let zero_delegations = delegations()
-        .range(deps.storage, None, None, cosmwasm_std::Order::Ascending)
-        .filter_map(|r| r.ok())
-        .filter(|(_k, v)| v.amount.amount == Uint128::zero())
-        .map(|(k, _v)| k)
-        .collect::<Vec<_>>();
-
-    for delegation in &zero_delegations {
-        delegations().remove(deps.storage, delegation.clone())?;
-    }
-
-    // similarly, if there exists any event that is scheduled to insert/remove delegation with 0 value, purge it
-    let delegate_events_to_purge = crate::delegations::storage::PENDING_DELEGATION_EVENTS
-        .range(deps.storage, None, None, cosmwasm_std::Order::Ascending)
-        .filter_map(|r| r.ok())
-        .filter(|(_k, v)| match v {
-            DelegationEvent::Delegate(d) => d.amount.amount == Uint128::zero(),
-            _ => false,
-        })
-        .map(|(k, _v)| k)
-        .collect::<Vec<_>>();
-
-    for delegation_event in delegate_events_to_purge {
-        crate::delegations::storage::PENDING_DELEGATION_EVENTS
-            .remove(deps.storage, delegation_event);
-    }
-
+pub fn migrate(_deps: DepsMut<'_>, _env: Env, _msg: MigrateMsg) -> Result<Response, ContractError> {
     Ok(Default::default())
 }
 

contracts/mixnet/src/delegations/queries.rs

@@ -9,25 +9,16 @@ use cosmwasm_std::{Api, Deps, Storage};
 use cw_storage_plus::{Bound, PrimaryKey};
 use mixnet_contract_common::mixnode::DelegationEvent;
 use mixnet_contract_common::{
-    delegation, Delegation, IdentityKey, PagedDelegatorDelegationsResponse,
-    PagedMixDelegationsResponse,
+    Delegation, IdentityKey, PagedDelegatorDelegationsResponse, PagedMixDelegationsResponse,
 };
 
 pub(crate) fn query_pending_delegation_events(
-    deps: Deps<'_>,
+    storage: &dyn Storage,
     owner_address: String,
-    proxy_address: Option<String>,
 ) -> Result<Vec<DelegationEvent>, ContractError> {
-    let validated_owner = deps.api.addr_validate(&owner_address)?;
-    let validated_proxy = proxy_address
-        .map(|proxy| deps.api.addr_validate(&proxy))
-        .transpose()?;
-
-    let key_prefix = delegation::generate_storage_key(&validated_owner, validated_proxy.as_ref());
-
     Ok(storage::PENDING_DELEGATION_EVENTS
-        .sub_prefix(key_prefix)
-        .range(deps.storage, None, None, Order::Ascending)
+        .sub_prefix(owner_address.as_bytes().to_vec())
+        .range(storage, None, None, Order::Ascending)
         .filter_map(|r| r.ok())
         .map(|(_key, delegation_event)| delegation_event)
         .collect::<Vec<DelegationEvent>>())
@@ -128,7 +119,7 @@ pub(crate) fn query_mixnode_delegation(
     proxy: Option<String>,
 ) -> Result<Vec<Delegation>, ContractError> {
     let validated_delegator = api.addr_validate(&delegator)?;
-    let proxy = proxy.map(|p| api.addr_validate(&p)).transpose()?;
+    let proxy = proxy.map(|p| api.addr_validate(&p).expect("Invalid proxy address"));
     let storage_key = (
         mix_identity.clone(),
         mixnet_contract_common::delegation::generate_storage_key(

contracts/mixnet/src/delegations/transactions.rs

@@ -28,12 +28,13 @@ pub fn try_reconcile_all_delegation_events(
         return Err(ContractError::Unauthorized);
     }
 
-    _try_reconcile_all_delegation_events(deps.storage)
+    _try_reconcile_all_delegation_events(deps.storage, deps.api)
 }
 
 // TODO: Error handling?
 pub(crate) fn _try_reconcile_all_delegation_events(
     storage: &mut dyn Storage,
+    api: &dyn Api,
 ) -> Result<Response, ContractError> {
     let pending_delegation_events = PENDING_DELEGATION_EVENTS
         .range(storage, None, None, Order::Ascending)
@@ -45,15 +46,12 @@ pub(crate) fn _try_reconcile_all_delegation_events(
     for (key, delegation_event) in pending_delegation_events {
         match delegation_event {
             DelegationEvent::Delegate(delegation) => {
-                // if for some reason the delegation is zero, don't do anything since it should be a no-op anyway
-                if delegation.amount.amount == Uint128::zero() {
-                    continue;
-                }
                 let event = try_reconcile_delegation(storage, delegation)?;
                 response = response.add_event(event);
             }
             DelegationEvent::Undelegate(pending_undelegate) => {
-                let undelegate_response = try_reconcile_undelegation(storage, &pending_undelegate)?;
+                let undelegate_response =
+                    try_reconcile_undelegation(storage, api, &pending_undelegate)?;
                 response = response.add_event(undelegate_response.event);
                 if let Some(msg) = undelegate_response.bank_msg {
                     response = response.add_message(msg);
@@ -201,17 +199,6 @@ pub(crate) fn _try_delegate_to_mixnode(
         proxy.clone(),
     );
 
-    if storage::PENDING_DELEGATION_EVENTS
-        .may_load(storage, delegation.event_storage_key())?
-        .is_some()
-    {
-        return Err(ContractError::DelegationEventAlreadyPending {
-            block_height,
-            identity: mix_identity.to_string(),
-            kind: "delgation".to_string(),
-        });
-    }
-
     storage::PENDING_DELEGATION_EVENTS.save(
         storage,
         delegation.event_storage_key(),
@@ -253,6 +240,7 @@ pub struct ReconcileUndelegateResponse {
 
 pub(crate) fn try_reconcile_undelegation(
     storage: &mut dyn Storage,
+    api: &dyn Api,
     pending_undelegate: &PendingUndelegate,
 ) -> Result<ReconcileUndelegateResponse, ContractError> {
     let delegation_map = storage::delegations();
@@ -278,10 +266,13 @@ pub(crate) fn try_reconcile_undelegation(
         });
     }
 
-    let reward = crate::rewards::transactions::calculate_delegator_reward(
+    let reward = crate::rewards::transactions::_try_compound_delegator_reward(
+        pending_undelegate.block_height(),
+        api,
         storage,
-        pending_undelegate.proxy_storage_key(),
+        pending_undelegate.delegate().as_str(),
         &pending_undelegate.mix_identity(),
+        None,
     )?;
 
     // Might want to introduce paging here
@@ -327,18 +318,13 @@ pub(crate) fn try_reconcile_undelegation(
         )?;
     }
 
-    // don't add a bank message if it would have resulted in attempting to send 0 tokens
-    let bank_msg = if total_delegation != Uint128::zero() {
-        Some(BankMsg::Send {
-            to_address: pending_undelegate
-                .proxy()
-                .as_ref()
-                .unwrap_or(&pending_undelegate.delegate())
-                .to_string(),
-            amount: coins(total_delegation.u128(), DENOM),
-        })
-    } else {
-        None
+    let bank_msg = BankMsg::Send {
+        to_address: pending_undelegate
+            .proxy()
+            .as_ref()
+            .unwrap_or(&pending_undelegate.delegate())
+            .to_string(),
+        amount: coins(total_delegation.u128(), DENOM),
     };
 
     mixnodes_storage::TOTAL_DELEGATION.update::<_, ContractError>(
@@ -376,7 +362,7 @@ pub(crate) fn try_reconcile_undelegation(
     );
 
     Ok(ReconcileUndelegateResponse {
-        bank_msg,
+        bank_msg: Some(bank_msg),
         wasm_msg,
         event,
     })
@@ -398,17 +384,6 @@ pub(crate) fn _try_remove_delegation_from_mixnode(
         env.block.height,
     );
 
-    if storage::PENDING_DELEGATION_EVENTS
-        .may_load(deps.storage, event.event_storage_key())?
-        .is_some()
-    {
-        return Err(ContractError::DelegationEventAlreadyPending {
-            block_height: event.block_height(),
-            identity: mix_identity,
-            kind: "undelgation".to_string(),
-        });
-    }
-
     PENDING_DELEGATION_EVENTS.save(
         deps.storage,
         event.event_storage_key(),
@@ -527,7 +502,7 @@ mod tests {
             )
             .is_ok());
 
-            _try_reconcile_all_delegation_events(&mut deps.storage).unwrap();
+            _try_reconcile_all_delegation_events(&mut deps.storage, &deps.api).unwrap();
 
             let expected = Delegation::new(
                 delegation_owner.clone(),
@@ -606,7 +581,7 @@ mod tests {
             )
             .is_ok());
 
-            _try_reconcile_all_delegation_events(&mut deps.storage).unwrap();
+            _try_reconcile_all_delegation_events(&mut deps.storage, &deps.api).unwrap();
 
             let expected = Delegation::new(
                 delegation_owner.clone(),
@@ -669,7 +644,7 @@ mod tests {
             )
             .unwrap();
 
-            _try_reconcile_all_delegation_events(&mut deps.storage).unwrap();
+            _try_reconcile_all_delegation_events(&mut deps.storage, &deps.api).unwrap();
 
             // let expected = Delegation::new(
             //     delegation_owner.clone(),
@@ -724,7 +699,7 @@ mod tests {
             )
             .unwrap();
 
-            _try_reconcile_all_delegation_events(&mut deps.storage).unwrap();
+            _try_reconcile_all_delegation_events(&mut deps.storage, &deps.api).unwrap();
 
             assert_eq!(
                 initial_height,
@@ -745,7 +720,7 @@ mod tests {
             )
             .unwrap();
 
-            _try_reconcile_all_delegation_events(&mut deps.storage).unwrap();
+            _try_reconcile_all_delegation_events(&mut deps.storage, &deps.api).unwrap();
 
             let delegations = crate::delegations::queries::query_mixnode_delegation(
                 &deps.storage,
@@ -790,7 +765,7 @@ mod tests {
             )
             .unwrap();
 
-            _try_reconcile_all_delegation_events(&mut deps.storage).unwrap();
+            _try_reconcile_all_delegation_events(&mut deps.storage, &deps.api).unwrap();
 
             assert_eq!(
                 initial_height,
@@ -811,7 +786,7 @@ mod tests {
             )
             .unwrap();
 
-            _try_reconcile_all_delegation_events(&mut deps.storage).unwrap();
+            _try_reconcile_all_delegation_events(&mut deps.storage, &deps.api).unwrap();
 
             assert_eq!(
                 initial_height,
@@ -899,7 +874,7 @@ mod tests {
             )
             .is_ok());
 
-            _try_reconcile_all_delegation_events(&mut deps.storage).unwrap();
+            _try_reconcile_all_delegation_events(&mut deps.storage, &deps.api).unwrap();
 
             let expected1 = Delegation::new(
                 delegation_owner.clone(),
@@ -964,7 +939,7 @@ mod tests {
                 identity.clone(),
             )
             .is_ok());
-            _try_reconcile_all_delegation_events(&mut deps.storage).unwrap();
+            _try_reconcile_all_delegation_events(&mut deps.storage, &deps.api).unwrap();
 
             // node's "total_delegation" is sum of both
             assert_eq!(
@@ -994,7 +969,7 @@ mod tests {
             )
             .unwrap();
 
-            _try_reconcile_all_delegation_events(&mut deps.storage).unwrap();
+            _try_reconcile_all_delegation_events(&mut deps.storage, &deps.api).unwrap();
 
             try_remove_mixnode(mock_env(), deps.as_mut(), mock_info(mixnode_owner, &[])).unwrap();
 
@@ -1082,7 +1057,7 @@ mod tests {
             )
             .unwrap();
 
-            _try_reconcile_all_delegation_events(&mut deps.storage).unwrap();
+            _try_reconcile_all_delegation_events(&mut deps.storage, &deps.api).unwrap();
 
             let _delegation = query_mixnode_delegation(
                 &deps.storage,
@@ -1152,7 +1127,7 @@ mod tests {
             )
             .unwrap();
 
-            _try_reconcile_all_delegation_events(&mut deps.storage).unwrap();
+            _try_reconcile_all_delegation_events(&mut deps.storage, &deps.api).unwrap();
 
             let delegation = query_mixnode_delegation(
                 &deps.storage,
@@ -1187,7 +1162,7 @@ mod tests {
                 )
             );
 
-            _try_reconcile_all_delegation_events(&mut deps.storage).unwrap();
+            _try_reconcile_all_delegation_events(&mut deps.storage, &deps.api).unwrap();
 
             assert!(test_helpers::read_delegation(
                 &deps.storage,
@@ -1220,7 +1195,7 @@ mod tests {
             )
             .is_ok());
 
-            _try_reconcile_all_delegation_events(&mut deps.storage).unwrap();
+            _try_reconcile_all_delegation_events(&mut deps.storage, &deps.api).unwrap();
 
             assert!(try_delegate_to_mixnode(
                 deps.as_mut(),
@@ -1230,7 +1205,7 @@ mod tests {
             )
             .is_ok());
 
-            _try_reconcile_all_delegation_events(&mut deps.storage).unwrap();
+            _try_reconcile_all_delegation_events(&mut deps.storage, &deps.api).unwrap();
 
             // sender1 undelegates
             try_remove_delegation_from_mixnode(
@@ -1241,7 +1216,7 @@ mod tests {
             )
             .unwrap();
 
-            _try_reconcile_all_delegation_events(&mut deps.storage).unwrap();
+            _try_reconcile_all_delegation_events(&mut deps.storage, &deps.api).unwrap();
             // but total delegation should still equal to what sender2 sent
             // node's "total_delegation" is sum of both
             assert_eq!(

contracts/mixnet/src/error.rs

@@ -158,14 +158,4 @@ pub enum ContractError {
 
     #[error("Epoch not initialized yet!")]
     EpochNotInitialized,
-
-    #[error("Invalid address: {0}")]
-    InvalidAddress(String),
-
-    #[error("Pending {kind} event  already exists at block {block_height} for mixnode {identity}")]
-    DelegationEventAlreadyPending {
-        block_height: u64,
-        identity: String,
-        kind: String, // delegation | undelegation
-    },
 }

contracts/mixnet/src/interval/transactions.rs

@@ -27,8 +27,9 @@ pub fn try_write_rewarded_set(
         return Err(ContractError::Unauthorized);
     }
 
-    // We don't want more then we need, less should be fine, as we could have less nodes bonded overall
-    if active_set_size > state.params.mixnode_active_set_size {
+    // sanity check to make sure the sending validator is in sync with the contract state
+    // (i.e. so that we'd known that top k nodes are actually expected to be active)
+    if active_set_size != state.params.mixnode_active_set_size {
         return Err(ContractError::UnexpectedActiveSetSize {
             received: active_set_size,
             expected: state.params.mixnode_active_set_size,
@@ -42,7 +43,16 @@ pub fn try_write_rewarded_set(
         });
     }
 
+    let last_update = storage::CURRENT_REWARDED_SET_HEIGHT.load(deps.storage)?;
     let block_height = env.block.height;
+
+    if last_update + crate::constants::REWARDED_SET_REFRESH_BLOCKS > block_height {
+        return Err(ContractError::TooFrequentRewardedSetUpdate {
+            last_update,
+            minimum_delay: crate::constants::REWARDED_SET_REFRESH_BLOCKS,
+            current_height: block_height,
+        });
+    }
     let num_nodes = rewarded_set.len();
 
     storage::save_rewarded_set(deps.storage, block_height, active_set_size, rewarded_set)?;
@@ -174,6 +184,21 @@ mod tests {
 
         // cannot be performed too soon after a previous update
         env.block.height = last_update + 1;
+        assert_eq!(
+            Err(ContractError::TooFrequentRewardedSetUpdate {
+                last_update,
+                minimum_delay: crate::constants::REWARDED_SET_REFRESH_BLOCKS,
+                current_height: last_update + 1,
+            }),
+            try_write_rewarded_set(
+                deps.as_mut(),
+                env.clone(),
+                authorised_sender.clone(),
+                full_rewarded_set.clone(),
+                current_state.params.mixnode_active_set_size
+            )
+        );
+
         // after successful rewarded set write, all internal storage structures are updated appropriately
         env.block.height = last_update + crate::constants::REWARDED_SET_REFRESH_BLOCKS;
         let expected_response = Response::new().add_event(new_change_rewarded_set_event(

contracts/mixnet/src/mixnodes/storage.rs

@@ -4,10 +4,10 @@
 use config::defaults::DENOM;
 use cosmwasm_std::{StdResult, Storage, Uint128};
 use cw_storage_plus::{Index, IndexList, IndexedSnapshotMap, Map, Strategy, UniqueIndex};
+use mixnet_contract_common::U128;
 use mixnet_contract_common::{
     reward_params::NodeEpochRewards, Addr, Coin, IdentityKeyRef, Layer, MixNode, MixNodeBond,
 };
-use mixnet_contract_common::{SphinxKey, U128};
 use serde::{Deserialize, Serialize};
 use std::fmt::{Display, Formatter};
 
@@ -17,7 +17,6 @@ const MIXNODES_PK_NAMESPACE: &str = "mn";
 const MIXNODES_PK_CHECKPOINTS: &str = "mn__check";
 const MIXNODES_PK_CHANGELOG: &str = "mn__change";
 const MIXNODES_OWNER_IDX_NAMESPACE: &str = "mno";
-const MIXNODES_SPHINX_IDX_NAMESPACE: &str = "mns";
 
 // paged retrieval limits for all queries and transactions
 pub(crate) const BOND_PAGE_MAX_LIMIT: u32 = 75;
@@ -28,15 +27,13 @@ pub(crate) const TOTAL_DELEGATION: Map<'_, IdentityKeyRef<'_>, Uint128> =
 
 pub(crate) struct MixnodeBondIndex<'a> {
     pub(crate) owner: UniqueIndex<'a, Addr, StoredMixnodeBond>,
-
-    pub(crate) sphinx_key: UniqueIndex<'a, SphinxKey, StoredMixnodeBond>,
 }
 
 // IndexList is just boilerplate code for fetching a struct's indexes
 // note that from my understanding this will be converted into a macro at some point in the future
 impl<'a> IndexList<StoredMixnodeBond> for MixnodeBondIndex<'a> {
     fn get_indexes(&'_ self) -> Box<dyn Iterator<Item = &'_ dyn Index<StoredMixnodeBond>> + '_> {
-        let v: Vec<&dyn Index<StoredMixnodeBond>> = vec![&self.owner, &self.sphinx_key];
+        let v: Vec<&dyn Index<StoredMixnodeBond>> = vec![&self.owner];
         Box::new(v.into_iter())
     }
 }
@@ -46,10 +43,6 @@ pub(crate) fn mixnodes<'a>(
 ) -> IndexedSnapshotMap<'a, IdentityKeyRef<'a>, StoredMixnodeBond, MixnodeBondIndex<'a>> {
     let indexes = MixnodeBondIndex {
         owner: UniqueIndex::new(|d| d.owner.clone(), MIXNODES_OWNER_IDX_NAMESPACE),
-        sphinx_key: UniqueIndex::new(
-            |d| d.mix_node.sphinx_key.clone(),
-            MIXNODES_SPHINX_IDX_NAMESPACE,
-        ),
     };
     IndexedSnapshotMap::new(
         MIXNODES_PK_NAMESPACE,

contracts/mixnet/src/mixnodes/transactions.rs

@@ -374,7 +374,6 @@ pub mod tests {
     use mixnet_contract_common::{
         ExecuteMsg, Layer, LayerDistribution, MixNode, PagedMixnodeResponse, QueryMsg,
     };
-    use rand::thread_rng;
 
     #[test]
     fn mixnode_add() {
@@ -410,7 +409,7 @@ pub mod tests {
 
         // if we send enough funds
         let info = mock_info("anyone", &tests::fixtures::good_mixnode_pledge());
-        let (msg, (identity, sphinx)) = tests::messages::valid_bond_mixnode_msg("anyone");
+        let (msg, identity) = tests::messages::valid_bond_mixnode_msg("anyone");
 
         // we get back a message telling us everything was OK
         let execute_response = execute(deps.as_mut(), mock_env(), info, msg);
@@ -431,7 +430,6 @@ pub mod tests {
         assert_eq!(
             &MixNode {
                 identity_key: identity,
-                sphinx_key: sphinx,
                 ..tests::fixtures::mix_node_fixture()
             },
             page.nodes[0].mix_node()
@@ -491,7 +489,7 @@ pub mod tests {
             .unwrap()
             .is_none());
 
-        let (msg, (identity, _)) = tests::messages::valid_bond_mixnode_msg("mix-owner");
+        let (msg, identity) = tests::messages::valid_bond_mixnode_msg("mix-owner");
 
         // it's all fine, owner is saved
         let execute_response = execute(deps.as_mut(), mock_env(), info, msg);
@@ -665,7 +663,7 @@ pub mod tests {
         let mut deps = test_helpers::init_contract();
 
         let info = mock_info("mix-owner", &tests::fixtures::good_mixnode_pledge());
-        let (bond_msg, (identity, _)) = tests::messages::valid_bond_mixnode_msg("mix-owner");
+        let (bond_msg, identity) = tests::messages::valid_bond_mixnode_msg("mix-owner");
         execute(deps.as_mut(), mock_env(), info, bond_msg.clone()).unwrap();
 
         assert_eq!(
@@ -846,39 +844,4 @@ pub mod tests {
         assert_eq!(bob_node.mix_node.identity_key, bob_identity);
         assert_eq!(bob_node.layer, mixnet_contract_common::Layer::Two);
     }
-
-    #[test]
-    fn adding_mixnode_with_duplicate_sphinx_key_errors_out() {
-        let mut deps = test_helpers::init_contract();
-
-        let keypair1 = crypto::asymmetric::identity::KeyPair::new(&mut thread_rng());
-        let keypair2 = crypto::asymmetric::identity::KeyPair::new(&mut thread_rng());
-        let sig1 = keypair1.private_key().sign_text("alice");
-        let sig2 = keypair1.private_key().sign_text("bob");
-
-        let info_alice = mock_info("alice", &tests::fixtures::good_mixnode_pledge());
-        let info_bob = mock_info("bob", &tests::fixtures::good_mixnode_pledge());
-
-        let mut mixnode = MixNode {
-            host: "1.2.3.4".to_string(),
-            mix_port: 1234,
-            verloc_port: 1234,
-            http_api_port: 1234,
-            sphinx_key: crypto::asymmetric::encryption::KeyPair::new(&mut thread_rng())
-                .public_key()
-                .to_base58_string(),
-            identity_key: keypair1.public_key().to_base58_string(),
-            version: "v0.1.2.3".to_string(),
-            profit_margin_percent: 10,
-        };
-
-        assert!(
-            try_add_mixnode(deps.as_mut(), mock_env(), info_alice, mixnode.clone(), sig1).is_ok()
-        );
-
-        mixnode.identity_key = keypair2.public_key().to_base58_string();
-
-        // change identity but reuse sphinx key
-        assert!(try_add_mixnode(deps.as_mut(), mock_env(), info_bob, mixnode, sig2).is_err());
-    }
 }

contracts/mixnet/src/rewards/queries.rs

@@ -46,19 +46,13 @@ pub fn query_delegator_reward(
     deps: Deps,
     owner: String,
     mix_identity: IdentityKey,
-    proxy: Option<String>,
 ) -> Result<Uint128, ContractError> {
-    let proxy = proxy.map(|p| {
-        deps.api
-            .addr_validate(&p)
-            .map_err(|_| ContractError::InvalidAddress(p))
-            .expect("proxy address is invalid")
-    });
-    let key = mixnet_contract_common::delegation::generate_storage_key(
-        &deps.api.addr_validate(&owner)?,
-        proxy.as_ref(),
-    );
-    super::transactions::calculate_delegator_reward(deps.storage, key, &mix_identity)
+    let owner_address = deps.api.addr_validate(&owner)?;
+    super::transactions::calculate_delegator_reward(
+        deps.storage,
+        owner_address.as_str(),
+        &mix_identity,
+    )
 }
 
 #[cfg(test)]

contracts/mixnet/src/rewards/storage.rs

@@ -14,8 +14,7 @@ pub(crate) const REWARD_POOL: Item<'_, Uint128> = Item::new("pool");
 // TODO: Do we need a migration for this?
 pub(crate) const REWARDING_STATUS: Map<'_, (u32, IdentityKey), RewardingStatus> = Map::new("rm");
 
-// This has to be a byte vector due to proxy delegastions and rewarding
-pub(crate) const DELEGATOR_REWARD_CLAIMED_HEIGHT: Map<'_, (Vec<u8>, IdentityKey), BlockHeight> =
+pub(crate) const DELEGATOR_REWARD_CLAIMED_HEIGHT: Map<'_, (Address, IdentityKey), BlockHeight> =
     Map::new("drc");
 pub(crate) const OPERATOR_REWARD_CLAIMED_HEIGHT: Map<'_, (Address, IdentityKey), BlockHeight> =
     Map::new("orc");

contracts/mixnet/src/rewards/transactions.rs

@@ -1,10 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use super::storage::{
-    self, epoch_reward_params_for_id, DELEGATOR_REWARD_CLAIMED_HEIGHT,
-    OPERATOR_REWARD_CLAIMED_HEIGHT,
-};
+use super::storage::{self, epoch_reward_params_for_id, DELEGATOR_REWARD_CLAIMED_HEIGHT};
 use crate::constants;
 use crate::delegations::storage as delegations_storage;
 use crate::delegations::transactions::_try_delegate_to_mixnode;
@@ -83,9 +80,9 @@ pub fn _try_compound_operator_reward(
         block_height,
     )?;
 
-    OPERATOR_REWARD_CLAIMED_HEIGHT.save(
+    DELEGATOR_REWARD_CLAIMED_HEIGHT.save(
         storage,
-        (owner.to_string(), bond.identity().to_string()),
+        (bond.identity().to_string(), owner.to_string()),
         &block_height,
     )?;
 
@@ -201,60 +198,31 @@ pub fn _try_compound_delegator_reward(
     mix_identity: &str,
     proxy: Option<Addr>,
 ) -> Result<Uint128, ContractError> {
-    let delegation_map = crate::delegations::storage::delegations();
-
-    let key = mixnet_contract_common::delegation::generate_storage_key(
-        &api.addr_validate(owner_address)?,
-        proxy.as_ref(),
-    );
-    let reward = calculate_delegator_reward(storage, key.clone(), mix_identity)?;
-    let mut compounded_delegation = reward;
-
-    // Might want to introduce paging here
-    let delegation_heights = delegation_map
-        .prefix((mix_identity.to_string(), key.clone()))
-        .keys(storage, None, None, cosmwasm_std::Order::Ascending)
-        .filter_map(|v| v.ok())
-        .collect::<Vec<u64>>();
-
-    for h in delegation_heights {
-        let delegation =
-            delegation_map.load(storage, (mix_identity.to_string(), key.clone(), h))?;
-        compounded_delegation += delegation.amount.amount;
-        delegation_map.replace(
-            storage,
-            (mix_identity.to_string(), key.clone(), h),
-            None,
-            Some(&delegation),
-        )?;
-    }
-
-    if compounded_delegation != Uint128::zero() {
-        _try_delegate_to_mixnode(
-            storage,
-            api,
-            block_height,
-            mix_identity,
-            owner_address,
-            Coin {
-                amount: reward,
-                denom: DENOM.to_string(),
-            },
-            proxy,
-        )?;
-    }
-
+    let reward = calculate_delegator_reward(storage, owner_address, mix_identity)?;
+    if _try_delegate_to_mixnode(
+        storage,
+        api,
+        block_height,
+        mix_identity,
+        owner_address,
+        Coin {
+            amount: reward,
+            denom: DENOM.to_string(),
+        },
+        proxy,
+    )
+    .is_ok()
     {
-        //TODO: Node exists all is well, life goes on, if it does not exist we'll just return the reward to the caller as there is nothing to do on the bond
+        // Node exists all is well, life goes on, if it does not exist we'll just return the reward to the caller as there is nothing to do on the bond
         if let Some(mut bond) = mixnodes().may_load(storage, mix_identity)? {
             bond.accumulated_rewards = Some(bond.accumulated_rewards() - reward);
             mixnodes().save(storage, mix_identity, &bond, block_height)?;
         }
-    }
+    };
 
     DELEGATOR_REWARD_CLAIMED_HEIGHT.save(
         storage,
-        (key, mix_identity.to_string()),
+        (mix_identity.to_string(), owner_address.to_string()),
         &block_height,
     )?;
 
@@ -266,17 +234,20 @@ pub fn _try_compound_delegator_reward(
 // + last_reward_claimed height is correctly used
 pub fn calculate_delegator_reward(
     storage: &dyn Storage,
-    key: Vec<u8>,
+    owner_address: &str,
     mix_identity: &str,
 ) -> Result<Uint128, ContractError> {
     let last_claimed_height = storage::DELEGATOR_REWARD_CLAIMED_HEIGHT
-        .load(storage, (key.clone(), mix_identity.to_string()))
+        .load(
+            storage,
+            (owner_address.to_string(), mix_identity.to_string()),
+        )
         .unwrap_or(0);
 
     // Get delegations newer then last_claimed_height, it would be nice to also fold this into the iteration bellow but it should be ok for now, as
     // I doubt folks refresh their delegations often
     let delegations = delegations_storage::delegations()
-        .prefix((mix_identity.to_string(), key))
+        .prefix((mix_identity.to_string(), owner_address.as_bytes().to_vec()))
         .range(storage, None, None, Order::Descending)
         .filter_map(|record| record.ok())
         .filter(|(height, _)| last_claimed_height <= *height)
@@ -895,8 +866,11 @@ pub mod tests {
         )
         .unwrap();
 
-        crate::delegations::transactions::_try_reconcile_all_delegation_events(&mut deps.storage)
-            .unwrap();
+        crate::delegations::transactions::_try_reconcile_all_delegation_events(
+            &mut deps.storage,
+            &deps.api,
+        )
+        .unwrap();
 
         let info = mock_info(rewarding_validator_address.as_ref(), &[]);
         env.block.height += 2 * constants::MINIMUM_BLOCK_AGE_FOR_REWARDING;
@@ -1011,8 +985,11 @@ pub mod tests {
         )
         .unwrap();
 
-        crate::delegations::transactions::_try_reconcile_all_delegation_events(&mut deps.storage)
-            .unwrap();
+        crate::delegations::transactions::_try_reconcile_all_delegation_events(
+            &mut deps.storage,
+            &deps.api,
+        )
+        .unwrap();
 
         let info = mock_info(rewarding_validator_address.as_ref(), &[]);
         env.block.height += 2 * constants::MINIMUM_BLOCK_AGE_FOR_REWARDING;
@@ -1048,8 +1025,6 @@ pub mod tests {
         );
         assert_eq!(mix_1_reward_result.reward().int(), 259114u128);
 
-        assert_eq!(mix_1.node_profit(&params).int(), 203558u128);
-
         let mix1_operator_reward = mix_1.operator_reward(&params);
 
         let mix1_delegator1_reward = mix_1.reward_delegation(Uint128::new(8000_000000), &params);
@@ -1060,11 +1035,6 @@ pub mod tests {
         assert_eq!(mix1_delegator1_reward, 73280);
         assert_eq!(mix1_delegator2_reward, 18320);
 
-        assert_eq!(
-            mix_1_reward_result.reward().int(),
-            mix1_operator_reward + mix1_delegator1_reward + mix1_delegator2_reward + 1
-        );
-
         assert_eq!(
             mix1_operator_reward + mix1_delegator1_reward + mix1_delegator2_reward + 1,
             mix_1_reward_result.reward().int()
@@ -1106,6 +1076,13 @@ pub mod tests {
                 + mix1_delegator2_reward
                 + 1 // There is a rounding error here it seems
         );
+        // assert_eq!(
+        //     mixnodes_storage::TOTAL_DELEGATION
+        //         .load(&deps.storage, &node_identity)
+        //         .unwrap()
+        //         .u128(),
+        //     pre_reward_delegation + mix1_delegator1_reward + mix1_delegator2_reward
+        // );
 
         assert_eq!(
             storage::REWARD_POOL.load(&deps.storage).unwrap().u128(),