Merge branch 'master' of github.com:entropyxyz/entropy-core into rota…

…te-parent-network-key-2-steps

CHANGELOG.md

@@ -32,6 +32,9 @@ At the moment this project **does not** adhere to
 ### Changed
 - Fix TSS `AccountId` keys in chainspec ([#993](https://github.com/entropyxyz/entropy-core/pull/993))
 
+### Removed
+-  Remove `prune_registration` extrinsic ([#1022](https://github.com/entropyxyz/entropy-core/pull/1022))
+
 ## [0.2.0](https://github.com/entropyxyz/entropy-core/compare/release/v0.1.0...release/v0.2.0) - 2024-07-11
 
 ### Breaking Changes

crates/testing-utils/src/lib.rs

@@ -21,6 +21,8 @@ pub mod constants;
 pub mod create_test_keyshares;
 mod node_proc;
 pub mod substrate_context;
-pub use entropy_tss::helpers::tests::spawn_testing_validators;
+pub use entropy_tss::helpers::tests::{
+    jump_start_network_with_signer as jump_start_network, spawn_testing_validators,
+};
 pub use node_proc::TestNodeProcess;
 pub use substrate_context::*;

crates/threshold-signature-server/src/helpers/tests.rs

@@ -32,6 +32,7 @@ use crate::{
         },
         logger::{Instrumentation, Logger},
         substrate::{query_chain, submit_transaction},
+        validator::get_signer_and_x25519_secret_from_mnemonic,
     },
     signing_client::ListenerState,
     AppState,
@@ -264,3 +265,25 @@ pub async fn unsafe_get(client: &reqwest::Client, query_key: String, port: u32)
 
     get_result.bytes().await.unwrap().into()
 }
+
+/// Mock the network being jump started by confirming a jump start even though no DKG took place,
+/// so that we can use pre-store parent keyshares for testing
+pub async fn jump_start_network_with_signer(
+    api: &OnlineClient<EntropyConfig>,
+    rpc: &LegacyRpcMethods<EntropyConfig>,
+    signer: &PairSigner<EntropyConfig, sr25519::Pair>,
+) {
+    let jump_start_request = entropy::tx().registry().jump_start_network();
+    let _result = submit_transaction(api, rpc, signer, &jump_start_request, None).await.unwrap();
+
+    let validators_names = vec![ValidatorName::Bob, ValidatorName::Charlie, ValidatorName::Dave];
+    for validator_name in validators_names {
+        let mnemonic = development_mnemonic(&Some(validator_name));
+        let (tss_signer, _static_secret) =
+            get_signer_and_x25519_secret_from_mnemonic(&mnemonic.to_string()).unwrap();
+        let jump_start_confirm_request =
+            entropy::tx().registry().confirm_jump_start(BoundedVec(EVE_VERIFYING_KEY.to_vec()));
+
+        submit_transaction(api, rpc, &tss_signer, &jump_start_confirm_request, None).await.unwrap();
+    }
+}

crates/threshold-signature-server/src/user/tests.rs

@@ -121,7 +121,8 @@ use crate::{
         substrate::{get_oracle_data, query_chain, submit_transaction},
         tests::{
             check_has_confirmation, check_if_confirmation, create_clients, initialize_test_logger,
-            remove_program, run_to_block, setup_client, spawn_testing_validators, unsafe_get,
+            jump_start_network_with_signer, remove_program, run_to_block, setup_client,
+            spawn_testing_validators, unsafe_get,
         },
         user::compute_hash,
         validator::get_signer_and_x25519_secret_from_mnemonic,
@@ -160,6 +161,7 @@ async fn test_get_signer_does_not_throw_err() {
     clean_tests();
 }
 
+#[ignore]
 #[tokio::test]
 #[serial]
 async fn test_sign_tx_no_chain() {
@@ -489,6 +491,7 @@ async fn signature_request_with_derived_account_works() {
     clean_tests();
 }
 
+#[ignore]
 #[tokio::test]
 #[serial]
 async fn test_sign_tx_no_chain_fail() {
@@ -614,6 +617,7 @@ async fn test_sign_tx_no_chain_fail() {
     clean_tests();
 }
 
+#[ignore]
 #[tokio::test]
 #[serial]
 async fn test_program_with_config() {
@@ -1079,6 +1083,7 @@ pub async fn verify_signature(
     }
 }
 
+#[ignore]
 #[tokio::test]
 #[serial]
 async fn test_fail_infinite_program() {
@@ -1157,6 +1162,7 @@ async fn test_fail_infinite_program() {
     }
 }
 
+#[ignore]
 #[tokio::test]
 #[serial]
 async fn test_device_key_proxy() {
@@ -1554,6 +1560,7 @@ async fn test_new_registration_flow() {
 
     clean_tests();
 }
+
 #[tokio::test]
 #[serial]
 async fn test_mutiple_confirm_done() {
@@ -1750,24 +1757,12 @@ pub async fn get_sign_tx_data(
     (validators_info, generic_msg, validator_ips_and_keys)
 }
 
+/// Mock jump starting the network
 pub async fn jump_start_network(
     api: &OnlineClient<EntropyConfig>,
     rpc: &LegacyRpcMethods<EntropyConfig>,
 ) {
     let alice = AccountKeyring::Alice;
     let signer = PairSigner::<EntropyConfig, sr25519::Pair>::new(alice.clone().into());
-
-    let jump_start_request = entropy::tx().registry().jump_start_network();
-    let _result = submit_transaction(api, rpc, &signer, &jump_start_request, None).await.unwrap();
-
-    let validators_names = vec![ValidatorName::Bob, ValidatorName::Charlie, ValidatorName::Dave];
-    for validator_name in validators_names {
-        let mnemonic = development_mnemonic(&Some(validator_name));
-        let (tss_signer, _static_secret) =
-            get_signer_and_x25519_secret_from_mnemonic(&mnemonic.to_string()).unwrap();
-        let jump_start_confirm_request =
-            entropy::tx().registry().confirm_jump_start(BoundedVec(EVE_VERIFYING_KEY.to_vec()));
-
-        submit_transaction(api, rpc, &tss_signer, &jump_start_confirm_request, None).await.unwrap();
-    }
+    jump_start_network_with_signer(api, rpc, &signer).await;
 }

crates/threshold-signature-server/tests/register_and_sign.rs

@@ -0,0 +1,107 @@
+// Copyright (C) 2023 Entropy Cryptography Inc.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use entropy_client::{
+    chain_api::{
+        entropy::runtime_types::bounded_collections::bounded_vec::BoundedVec,
+        entropy::runtime_types::pallet_registry::pallet::ProgramInstance, get_api, get_rpc,
+        EntropyConfig,
+    },
+    client as test_client, Hasher,
+};
+use entropy_kvdb::clean_tests;
+use entropy_testing_utils::{
+    constants::{
+        AUXILARY_DATA_SHOULD_SUCCEED, PREIMAGE_SHOULD_SUCCEED, TEST_PROGRAM_WASM_BYTECODE,
+    },
+    jump_start_network, spawn_testing_validators, test_node_process_testing_state,
+};
+use serial_test::serial;
+use sp_core::{sr25519, Pair};
+use sp_keyring::AccountKeyring;
+use subxt::{tx::PairSigner, utils::AccountId32};
+use synedrion::k256::ecdsa::VerifyingKey;
+
+#[tokio::test]
+#[serial]
+async fn integration_test_register_and_sign() {
+    clean_tests();
+    let account_owner = AccountKeyring::Ferdie.pair();
+    let signature_request_author = AccountKeyring::One;
+
+    let add_parent_key = true;
+    let (_validator_ips, _validator_ids) = spawn_testing_validators(add_parent_key).await;
+
+    let force_authoring = true;
+    let substrate_context = test_node_process_testing_state(force_authoring).await;
+    let api = get_api(&substrate_context.ws_url).await.unwrap();
+    let rpc = get_rpc(&substrate_context.ws_url).await.unwrap();
+
+    // Jumpstart the network
+    let alice = AccountKeyring::Alice;
+    let signer = PairSigner::<EntropyConfig, sr25519::Pair>::new(alice.clone().into());
+    jump_start_network(&api, &rpc, &signer).await;
+
+    // Store a program
+    let program_pointer = test_client::store_program(
+        &api,
+        &rpc,
+        &account_owner,
+        TEST_PROGRAM_WASM_BYTECODE.to_owned(),
+        vec![],
+        vec![],
+        vec![],
+    )
+    .await
+    .unwrap();
+
+    // Register, using that program
+    let register_on_chain = true;
+    let (verifying_key, _registered_info) = test_client::register(
+        &api,
+        &rpc,
+        account_owner.clone(),
+        AccountId32(account_owner.public().0),
+        BoundedVec(vec![ProgramInstance { program_pointer, program_config: vec![] }]),
+        register_on_chain,
+    )
+    .await
+    .unwrap();
+
+    // Sign a message
+    let recoverable_signature = test_client::sign(
+        &api,
+        &rpc,
+        signature_request_author.pair(),
+        verifying_key,
+        PREIMAGE_SHOULD_SUCCEED.to_vec(),
+        Some(AUXILARY_DATA_SHOULD_SUCCEED.to_vec()),
+    )
+    .await
+    .unwrap();
+
+    // Check the signature
+    let message_should_succeed_hash = Hasher::keccak(PREIMAGE_SHOULD_SUCCEED);
+    let recovery_key_from_sig = VerifyingKey::recover_from_prehash(
+        &message_should_succeed_hash,
+        &recoverable_signature.signature,
+        recoverable_signature.recovery_id,
+    )
+    .unwrap();
+    assert_eq!(
+        verifying_key.to_vec(),
+        recovery_key_from_sig.to_encoded_point(true).to_bytes().to_vec()
+    );
+}

crates/threshold-signature-server/tests/sign.rs

@@ -33,6 +33,7 @@ use serial_test::serial;
 use sp_keyring::AccountKeyring;
 use synedrion::k256::ecdsa::VerifyingKey;
 
+#[ignore]
 #[tokio::test]
 #[serial]
 async fn integration_test_sign_public() {

crates/threshold-signature-server/tests/sign_eth_tx.rs

@@ -42,6 +42,7 @@ use synedrion::k256::ecdsa::VerifyingKey;
 
 const GOERLI_CHAIN_ID: u64 = 5;
 
+#[ignore]
 #[tokio::test]
 #[serial]
 async fn integration_test_sign_eth_tx() {

pallets/registry/src/benchmarking.rs

@@ -251,34 +251,6 @@ benchmarks! {
     assert!(RegisteredOnChain::<T>::contains_key(expected_verifying_key));
   }
 
-  prune_registration {
-    let p in 1 .. T::MaxProgramHashes::get();
-    let program_modification_account: T::AccountId = whitelisted_caller();
-    let program = vec![0u8];
-    let configuration_schema = vec![1u8];
-    let auxiliary_data_schema = vec![2u8];
-    let oracle_data_pointer = vec![3u8];
-    let program_hash = T::Hashing::hash(&program);
-    let programs_info = BoundedVec::try_from(vec![ProgramInstance {
-      program_pointer: program_hash,
-      program_config: vec![],
-  }]).unwrap();
-    Programs::<T>::insert(program_hash, ProgramInfo {bytecode: program, configuration_schema, auxiliary_data_schema, oracle_data_pointer, deployer: program_modification_account.clone(), ref_counter: 1});
-    let sig_req_account: T::AccountId = whitelisted_caller();
-    let balance = <T as pallet_staking_extension::Config>::Currency::minimum_balance() * 100u32.into();
-    let _ = <T as pallet_staking_extension::Config>::Currency::make_free_balance_be(&sig_req_account, balance);
-      <Registering<T>>::insert(&sig_req_account, RegisteringDetails::<T> {
-        program_modification_account: sig_req_account.clone(),
-        confirmations: vec![],
-        programs_data: programs_info,
-        verifying_key: Some(BoundedVec::default()),
-        version_number: T::KeyVersionNumber::get()
-    });
-  }: _(RawOrigin::Signed(sig_req_account.clone()))
-  verify {
-    assert_last_event::<T>(Event::RegistrationCancelled(sig_req_account.clone()).into());
-  }
-
   change_program_instance {
     let n in 1 .. T::MaxProgramHashes::get();
     let o in 1 .. T::MaxProgramHashes::get();