chore: build and test compiling

build.rs

@@ -3,7 +3,7 @@ use blueprint_sdk::build;
 fn main() {
     let contract_dirs: Vec<&str> = vec!["./contracts"];
     build::utils::soldeer_install();
-    build::utils::soldeer_update();
+    // build::utils::soldeer_update();
     build::utils::build_contracts(contract_dirs);
 
     println!("cargo:rerun-if-changed=src/lib.rs");

src/context.rs

@@ -2,14 +2,12 @@ use crate::decrypt::DecryptState;
 use crate::setup::SilentThresholdEncryptionKeypair;
 use ark_bn254::Bn254;
 use blueprint_sdk as sdk;
-use blueprint_sdk::macros::core::Gadget;
 use blueprint_sdk::networking::service_handle::NetworkServiceHandle;
 use blueprint_sdk::networking::InstanceMsgPublicKey;
 use blueprint_sdk::stores::local_database::LocalDatabase;
 use color_eyre::eyre;
 use color_eyre::eyre::eyre;
 use color_eyre::{Report, Result};
-use k256::EncodedPoint;
 use sdk::clients::GadgetServicesClient;
 use sdk::config::GadgetConfiguration;
 use sdk::contexts::keystore::KeystoreContext;

src/jobs.rs

@@ -1,5 +1,4 @@
-use crate::decrypt::{DecryptState, Msg, PartialDecryptionMessage};
-use crate::setup::SilentThresholdEncryptionKeypair;
+use crate::decrypt::Msg;
 use crate::SilentTimelockEncryptionBlueprint;
 use api::services::events::JobCalled;
 use ark_bn254::Bn254;
@@ -9,38 +8,16 @@ use blueprint_sdk::event_listeners::tangle::events::TangleEventListener;
 use blueprint_sdk::event_listeners::tangle::services::{services_post_processor, services_pre_processor};
 use blueprint_sdk::tangle_subxt::tangle_testnet_runtime::api::runtime_types::tangle_primitives::services::service::BlueprintServiceManager;
 use blueprint_sdk as sdk;
-use blueprint_sdk::macros::core::Gadget;
 use blueprint_sdk::networking::round_based_compat::RoundBasedNetworkAdapter;
-use blueprint_sdk::networking::service_handle::NetworkServiceHandle;
 use blueprint_sdk::networking::InstanceMsgPublicKey;
-use blueprint_sdk::stores::local_database::LocalDatabase;
-use color_eyre::eyre;
-use color_eyre::eyre::eyre;
-use color_eyre::{Report, Result};
-use gadget_crypto::hashing::sha2_256;
-use k256::EncodedPoint;
+use color_eyre::Result;
 use round_based::PartyIndex;
-use sdk::clients::GadgetServicesClient;
-use sdk::config::GadgetConfiguration;
-use sdk::contexts::keystore::KeystoreContext;
 use sdk::contexts::tangle::TangleClientContext;
-use sdk::crypto::sp_core::SpSr25519;
-use sdk::crypto::tangle_pair_signer::sp_core;
-use sdk::keystore::backends::Backend;
 use sdk::logging;
-use sdk::macros::contexts::{KeystoreContext, ServicesContext, TangleClientContext};
-use sdk::tangle_subxt;
 use sdk::tangle_subxt::tangle_testnet_runtime::api;
 use silent_threshold_encryption::encryption::Ciphertext;
-use silent_threshold_encryption::kzg::PowersOfTau;
 use silent_threshold_encryption::setup::{AggregateKey, SecretKey};
-use sp_core::ecdsa::Public;
-use std::collections::btree_map::BTreeMap;
-use std::collections::hash_set::HashSet;
 use std::collections::HashMap;
-use std::path::PathBuf;
-use std::sync::Arc;
-use tangle_subxt::subxt_core::utils::AccountId32;
 
 use crate::context::{ServiceContext, KEYPAIR_KEY};
 use crate::decrypt::{threshold_decrypt_protocol, DecryptError};
@@ -229,23 +206,3 @@ pub async fn decrypt_ciphertext(
     println!("Decrypt ciphertext job completed successfully");
     Ok(decryption)
 }
-
-pub const KEYGEN_SALT: &str = "silent_timelock_encryption";
-pub const META_SALT: &str = "silent";
-
-/// Helper function to compute deterministic hashes for the keygen process
-fn compute_deterministic_hashes(n: u16, blueprint_id: u64, call_id: u64) -> ([u8; 32], [u8; 32]) {
-    let mut meta_bytes = Vec::new();
-    meta_bytes.extend_from_slice(&n.to_be_bytes());
-    meta_bytes.extend_from_slice(&blueprint_id.to_be_bytes());
-    meta_bytes.extend_from_slice(&call_id.to_be_bytes());
-    meta_bytes.extend_from_slice(META_SALT.as_bytes());
-    let meta_hash = sha2_256(&meta_bytes);
-
-    let mut deterministic_bytes = Vec::new();
-    deterministic_bytes.extend_from_slice(&meta_hash);
-    deterministic_bytes.extend_from_slice(KEYGEN_SALT.as_bytes());
-    let deterministic_hash = sha2_256(&deterministic_bytes);
-
-    (meta_hash, deterministic_hash)
-}

src/lib.rs

@@ -19,7 +19,7 @@ mod e2e {
     use crate::decrypt::DecryptState;
     use crate::jobs::DecryptCiphertextEventHandler;
     use crate::setup::setup;
-    use alloy_primitives::Bytes;
+    use blueprint_sdk::alloy::primitives::Bytes;
     use api::runtime_types::bounded_collections::bounded_vec::BoundedVec;
     use api::runtime_types::tangle_primitives::services::field::Field;
     use api::services::calls::types::call::Args;
@@ -29,21 +29,22 @@ mod e2e {
     use ark_std::UniformRand;
     use blueprint_sdk::alloy::network::EthereumWallet;
     use blueprint_sdk::alloy::providers::{ProviderBuilder, WsConnect};
+    use blueprint_sdk::alloy::signers::local::PrivateKeySigner;
+    use blueprint_sdk::contexts::keystore::KeystoreContext;
     use blueprint_sdk::contexts::tangle::TangleClient;
+    use blueprint_sdk::keystore::backends::Backend;
     use blueprint_sdk::logging::{self, error, info};
     use blueprint_sdk::tangle_subxt::parity_scale_codec::Encode;
     use blueprint_sdk::tangle_subxt::tangle_testnet_runtime::api;
     use blueprint_sdk::tangle_subxt::tangle_testnet_runtime::api::runtime_types::tangle_primitives::services::service::BlueprintServiceManager;
-    use blueprint_sdk::tangle_subxt::subxt::tx::signer::Signer;
     use blueprint_sdk::testing::tempfile;
     use blueprint_sdk::testing::utils::harness::TestHarness;
     use blueprint_sdk::testing::utils::tangle::node::transactions::{
-        get_next_call_id, submit_job, wait_for_completion_of_tangle_job
+        get_next_call_id, submit_job, wait_for_completion_of_tangle_job,
     };
     use blueprint_sdk::testing::utils::tangle::TangleTestHarness;
     use color_eyre::eyre::{self, eyre};
     use gadget_crypto::sp_core::SpEcdsa;
-    use gadget_crypto_tangle_pair_signer::TanglePairSigner;
     use silent_threshold_encryption::kzg::KZG10;
 
     #[tokio::test(flavor = "multi_thread")]
@@ -79,7 +80,7 @@ mod e2e {
             keypairs.push(keypair);
         }
 
-        let tangle_client = TangleClient::new(*harness.env()).await?;
+        let tangle_client = TangleClient::new(harness.env().clone()).await?;
         let blueprint_address = api::storage().services().blueprints(blueprint_id);
         let blueprint = tangle_client
             .storage()
@@ -88,7 +89,7 @@ mod e2e {
             .fetch(&blueprint_address)
             .await?;
 
-        let (owner, blueprint) = match blueprint {
+        let (_, blueprint) = match blueprint {
             Some((owner, blueprint)) => (owner, blueprint),
             None => return Err(eyre!("Blueprint not found")),
         };
@@ -98,23 +99,37 @@ mod e2e {
         };
 
         let handles = test_env.node_handles().await;
-        for handle in handles {
+        let binding = handles.clone();
+        let first_signer = binding[0].signer();
+        for handle in &handles {
             let config = handle.gadget_config().await;
-            let blueprint_ctx = ServiceContext::new(config.clone(), params, service_id).await?;
+            let blueprint_ctx =
+                ServiceContext::new(config.clone(), params.clone(), service_id).await?;
 
             let keygen_job =
                 DecryptCiphertextEventHandler::new(&config, blueprint_ctx.clone()).await?;
             handle.add_job(keygen_job).await;
         }
 
         for (index, keypair) in keypairs.iter().enumerate() {
-            let signer = handlers[index].signer();
+            let public_key = handles[index]
+                .clone()
+                .gadget_config()
+                .await
+                .keystore()
+                .first_local::<SpEcdsa>()?;
+            let secret_key = handles[index]
+                .gadget_config()
+                .await
+                .keystore()
+                .get_secret::<SpEcdsa>(&public_key)?;
+            let signer = PrivateKeySigner::from_slice(&secret_key.seed())?;
             println!("Registering public key for operator {}", signer.address());
             let wallet = EthereumWallet::new(signer);
             let provider = ProviderBuilder::new()
                 .with_recommended_fillers()
                 .wallet(wallet)
-                .on_ws(WsConnect::new(harness.ws_endpoint))
+                .on_ws(WsConnect::new(harness.ws_endpoint.clone()))
                 .await
                 .unwrap();
             // Register the STE public keys for each operator with the contract
@@ -162,7 +177,7 @@ mod e2e {
         // Submit the decryption job
         if let Err(err) = submit_job(
             &tangle_client,
-            handles[0].signer(),
+            first_signer,
             service_id,
             0, // DECRYPT_CIPHERTEXT_JOB_ID
             job_args,

src/main.rs

@@ -19,9 +19,8 @@ use blueprint_sdk::tangle_subxt::subxt::utils::AccountId32;
 use blueprint_sdk::tangle_subxt::tangle_testnet_runtime::api;
 use blueprint_sdk::utils::evm::get_wallet_provider_http;
 use color_eyre::Result;
-use gadget_crypto::sp_core::{SpEcdsa, SpEcdsaPair, SpSr25519};
+use gadget_crypto::sp_core::{SpEcdsa, SpSr25519};
 use gadget_crypto::tangle_pair_signer::sp_core::Pair;
-use gadget_crypto::tangle_pair_signer::TanglePairSigner;
 use silent_threshold_encryption::kzg::{PowersOfTau, KZG10};
 use silent_timelock_encryption_blueprint::context::{ServiceContext, KEYPAIR_KEY};
 use silent_timelock_encryption_blueprint::jobs::DecryptCiphertextEventHandler;

tests/aggregate.rs

@@ -3,23 +3,23 @@ use ark_ec::pairing::{Pairing, PairingOutput};
 use ark_poly::univariate::DensePolynomial;
 use ark_std::UniformRand;
 use blueprint_sdk::logging;
+use color_eyre::eyre;
 use rand::thread_rng;
 use round_based::sim::Simulation;
 use silent_threshold_encryption::encryption::encrypt;
 use silent_threshold_encryption::kzg::KZG10;
 use silent_threshold_encryption::setup::SecretKey;
-use silent_timelock_encryption_blueprint::decrypt::Msg;
+use silent_timelock_encryption_blueprint::decrypt::{DecryptState, Msg};
 use silent_timelock_encryption_blueprint::setup::from_bytes;
 use std::sync::Arc;
-use tokio::time::error::Error;
 
 #[tokio::test]
 async fn simulate_decryption() {
     logging::setup_log();
     setup_ste_keys().await;
 }
 
-async fn setup_ste_keys() {
+async fn setup_ste_keys() -> Result<(), eyre::Error> {
     let max_degree = 1 << 3;
     let tau = <Bn254 as Pairing>::ScalarField::rand(&mut ark_std::test_rng());
     let params =
@@ -86,43 +86,41 @@ async fn setup_ste_keys() {
     let agg_key = Arc::new(agg_key);
     let params = Arc::new(params);
 
-    let mut simulation = Simulation::<Msg>::new();
-    let mut tasks = vec![];
+    let mut simulation = Simulation::<_, Msg>::empty();
     for i in 0..n {
-        let party = simulation.add_party();
-        let output = tokio::spawn({
-            let ct_clone = Arc::clone(&ct); // Clone the Arc for the async block
-            let parsed_ste_sk_clone = Arc::clone(&parsed_ste_sk);
-            let agg_key_clone = Arc::clone(&agg_key);
-            let params_clone = Arc::clone(&params);
-            async move {
-                let output =
-                    silent_timelock_encryption_blueprint::decrypt::threshold_decrypt_protocol(
-                        party,
-                        i as u16,
-                        t as u16,
-                        n as u16,
-                        &parsed_ste_sk_clone[i],
-                        &ct_clone,
-                        &agg_key_clone,
-                        &params_clone,
-                    )
-                    .await
-                    .unwrap();
-                Result::<_, Error>::Ok(output)
-            }
+        let ct_clone = Arc::clone(&ct); // Clone the Arc for the async block
+        let parsed_ste_sk_clone = Arc::clone(&parsed_ste_sk);
+        let agg_key_clone = Arc::clone(&agg_key);
+        let params_clone = Arc::clone(&params);
+        simulation.add_async_party(|party| async move {
+            let output = silent_timelock_encryption_blueprint::decrypt::threshold_decrypt_protocol(
+                party,
+                i as u16,
+                t as u16,
+                n as u16,
+                &parsed_ste_sk_clone[i],
+                &ct_clone,
+                &agg_key_clone,
+                &params_clone,
+            )
+            .await
+            .unwrap();
+            Result::<_, eyre::Error>::Ok(output)
         });
-        tasks.push(output);
     }
 
-    let mut outputs = Vec::with_capacity(tasks.len());
+    let mut outputs = Vec::with_capacity(n as usize);
+    let tasks = simulation.run()?;
     for task in tasks {
-        outputs.push(task.await.unwrap().unwrap());
+        outputs.push(task);
     }
+    let outputs = outputs.into_iter().collect::<Result<Vec<_>, _>>()?;
 
     let dec_key_bytes = outputs[0].decryption_result.as_ref().unwrap();
     let dec_key: PairingOutput<Bn254> = from_bytes(dec_key_bytes);
     assert_eq!(dec_key, ct.enc_key);
 
     println!("Tasks completed");
+
+    Ok(())
 }