test: extend capabilities to create invalid transactions

Author: jns-ps

crates/common/src/transaction_builder.rs

@@ -26,8 +26,8 @@ impl UncommittedTransaction<'_> {
         let hc = self
             .builder
             .hashchains
-            .get_mut(&self.transaction.id)
-            .expect("Hashchain should be found");
+            .entry(self.transaction.id.clone())
+            .or_insert_with(Hashchain::empty);
 
         hc.add_entry(self.transaction.entry.clone())
             .expect("Adding transaction entry to hashchain should work");
@@ -114,16 +114,16 @@ impl TransactionBuilder {
         }
     }
 
-    pub fn create_account_with_random_key(
+    pub fn create_account_with_random_key_signed(
         &mut self,
         id: &str,
         service_id: &str,
     ) -> UncommittedTransaction {
-        let random_signing_key = SigningKey::new_ed25519();
-        self.create_account_for_existing_service(id, service_id, random_signing_key)
+        let account_signing_key = SigningKey::new_ed25519();
+        self.create_account_signed(id, service_id, account_signing_key)
     }
 
-    pub fn create_account_for_existing_service(
+    pub fn create_account_signed(
         &mut self,
         id: &str,
         service_id: &str,
@@ -136,6 +136,16 @@ impl TransactionBuilder {
         self.create_account(id, service_id, &service_signing_key, signing_key)
     }
 
+    pub fn create_account_with_random_key(
+        &mut self,
+        id: &str,
+        service_id: &str,
+        service_signing_key: &SigningKey,
+    ) -> UncommittedTransaction {
+        let account_signing_key = SigningKey::new_ed25519();
+        self.create_account(id, service_id, service_signing_key, account_signing_key)
+    }
+
     pub fn create_account(
         &mut self,
         id: &str,
@@ -203,11 +213,9 @@ impl TransactionBuilder {
         signing_key: &SigningKey,
         key_idx: usize,
     ) -> UncommittedTransaction {
-        let Some(hc) = self.hashchains.get(id) else {
-            panic!("No existing hashchain found for {}", id)
-        };
+        let last_hash = self.hashchains.get(id).map_or(Digest::zero(), Hashchain::last_hash);
 
-        let entry = HashchainEntry::new_add_key(key, hc.last_hash(), signing_key, key_idx);
+        let entry = HashchainEntry::new_add_key(key, last_hash, signing_key, key_idx);
 
         UncommittedTransaction {
             transaction: Transaction {
@@ -238,9 +246,9 @@ impl TransactionBuilder {
         signing_key: &SigningKey,
         key_idx: usize,
     ) -> UncommittedTransaction {
-        let hc = self.hashchains.get(id).expect("No existing hashchain found for");
+        let last_hash = self.hashchains.get(id).map_or(Digest::zero(), Hashchain::last_hash);
 
-        let entry = HashchainEntry::new_revoke_key(key, hc.last_hash(), signing_key, key_idx);
+        let entry = HashchainEntry::new_revoke_key(key, last_hash, signing_key, key_idx);
 
         UncommittedTransaction {
             transaction: Transaction {
@@ -359,15 +367,10 @@ impl TransactionBuilder {
         signing_key: &SigningKey,
         key_idx: usize,
     ) -> UncommittedTransaction {
-        let hc = self.hashchains.get(id).expect("Hashchain to add data on should be found");
-
-        let entry = HashchainEntry::new_add_data(
-            data,
-            data_signature,
-            hc.last_hash(),
-            signing_key,
-            key_idx,
-        );
+        let last_hash = self.hashchains.get(id).map_or(Digest::zero(), Hashchain::last_hash);
+
+        let entry =
+            HashchainEntry::new_add_data(data, data_signature, last_hash, signing_key, key_idx);
 
         UncommittedTransaction {
             transaction: Transaction {

crates/common/src/tree/mod.rs

@@ -39,7 +39,8 @@ mod tests {
         };
         assert!(insert_proof.verify().is_ok());
 
-        let account_tx = tx_builder.create_account_with_random_key("acc_1", "service_1").commit();
+        let account_tx =
+            tx_builder.create_account_with_random_key_signed("acc_1", "service_1").commit();
 
         let Proof::Insert(insert_proof) = tree.process_transaction(account_tx).unwrap() else {
             panic!("Processing transaction did not return the expected insert proof");
@@ -63,8 +64,14 @@ mod tests {
         let mut tree = KeyDirectoryTree::new(Arc::new(MockTreeStore::default()));
         let mut tx_builder = TransactionBuilder::new();
 
+        let service_signing_key = SigningKey::new_ed25519();
+
         let invalid_account_tx = tx_builder
-            .create_account_with_random_key("acc_1", "service_id_that_does_not_exist")
+            .create_account_with_random_key(
+                "acc_1",
+                "service_id_that_does_not_exist",
+                &service_signing_key,
+            )
             .build();
 
         let insertion_result = tree.process_transaction(invalid_account_tx);
@@ -108,9 +115,10 @@ mod tests {
         let mut tx_builder = TransactionBuilder::new();
 
         let service_tx = tx_builder.register_service_with_random_keys("service_1").commit();
-        let account_tx = tx_builder.create_account_with_random_key("acc_1", "service_1").commit();
+        let account_tx =
+            tx_builder.create_account_with_random_key_signed("acc_1", "service_1").commit();
         let account_with_same_id_tx =
-            tx_builder.create_account_with_random_key("acc_1", "service_1").build();
+            tx_builder.create_account_with_random_key_signed("acc_1", "service_1").build();
 
         let Proof::Insert(insert_proof) = tree.process_transaction(service_tx).unwrap() else {
             panic!("Processing service registration failed")
@@ -132,7 +140,8 @@ mod tests {
         let mut tx_builder = TransactionBuilder::new();
 
         let service_tx = tx_builder.register_service_with_random_keys("service_1").commit();
-        let acc_tx = tx_builder.create_account_with_random_key("acc_1", "service_1").commit();
+        let acc_tx =
+            tx_builder.create_account_with_random_key_signed("acc_1", "service_1").commit();
 
         tree.process_transaction(service_tx).unwrap();
         tree.process_transaction(acc_tx).unwrap();
@@ -161,8 +170,8 @@ mod tests {
 
         // This is a signing key not known to the storage yet
         let random_signing_key = SigningKey::new_ed25519();
-        // This transaction shall be invalid, because it is signed with a unknown key
-        let invalid_key_tx = tx_builder.add_random_key("acc_1", &random_signing_key, 0).commit();
+        // This transaction shall be invalid, because it is signed with an unknown key
+        let invalid_key_tx = tx_builder.add_random_key("acc_1", &random_signing_key, 0).build();
 
         let result = tree.process_transaction(invalid_key_tx);
         assert!(result.is_err());
@@ -187,8 +196,10 @@ mod tests {
         let mut tx_builder = TransactionBuilder::new();
 
         let service_tx = tx_builder.register_service_with_random_keys("service_1").commit();
-        let acc1_tx = tx_builder.create_account_with_random_key("acc_1", "service_1").commit();
-        let acc2_tx = tx_builder.create_account_with_random_key("acc_2", "service_1").commit();
+        let acc1_tx =
+            tx_builder.create_account_with_random_key_signed("acc_1", "service_1").commit();
+        let acc2_tx =
+            tx_builder.create_account_with_random_key_signed("acc_2", "service_1").commit();
 
         tree.process_transaction(service_tx).unwrap();
 
@@ -224,8 +235,10 @@ mod tests {
         let mut tx_builder = TransactionBuilder::new();
 
         let service_tx = tx_builder.register_service_with_random_keys("service_1").commit();
-        let acc1_tx = tx_builder.create_account_with_random_key("acc_1", "service_1").commit();
-        let acc2_tx = tx_builder.create_account_with_random_key("acc_2", "service_1").commit();
+        let acc1_tx =
+            tx_builder.create_account_with_random_key_signed("acc_1", "service_1").commit();
+        let acc2_tx =
+            tx_builder.create_account_with_random_key_signed("acc_2", "service_1").commit();
 
         tree.process_transaction(service_tx).unwrap();
         tree.process_transaction(acc1_tx).unwrap();
@@ -239,7 +252,7 @@ mod tests {
         let last_proof = tree.process_transaction(add_key_to_2_tx).unwrap();
 
         // Update account_2 using the correct key index
-        let Proof::Insert(insert_proof) = last_proof else {
+        let Proof::Update(update_proof) = last_proof else {
             panic!("Expetced insert proof for transaction");
         };
 
@@ -251,7 +264,10 @@ mod tests {
 
         assert!(matches!(get_result1, Found(hc, _) if &hc == test_hashchain_acc1));
         assert!(matches!(get_result2, Found(hc, _) if &hc == test_hashchain_acc2));
-        assert_eq!(insert_proof.new_root, tree.get_commitment().unwrap());
+        assert_eq!(
+            Digest::from(update_proof.new_root),
+            tree.get_commitment().unwrap()
+        );
     }
 
     #[test]
@@ -260,7 +276,8 @@ mod tests {
         let mut tx_builder = TransactionBuilder::new();
 
         let service_tx = tx_builder.register_service_with_random_keys("service_1").commit();
-        let account1_tx = tx_builder.create_account_with_random_key("acc_1", "service_1").commit();
+        let account1_tx =
+            tx_builder.create_account_with_random_key_signed("acc_1", "service_1").commit();
 
         tree.process_transaction(service_tx).unwrap();
 
@@ -277,8 +294,10 @@ mod tests {
         let mut tx_builder = TransactionBuilder::new();
 
         let service_tx = tx_builder.register_service_with_random_keys("service_1").commit();
-        let account1_tx = tx_builder.create_account_with_random_key("acc_1", "service_1").commit();
-        let account2_tx = tx_builder.create_account_with_random_key("acc_2", "service_2").commit();
+        let account1_tx =
+            tx_builder.create_account_with_random_key_signed("acc_1", "service_1").commit();
+        let account2_tx =
+            tx_builder.create_account_with_random_key_signed("acc_2", "service_1").commit();
 
         tree.process_transaction(service_tx).unwrap();
 

crates/node_types/prover/src/prover/tests.rs

@@ -22,10 +22,10 @@ fn create_mock_transactions(service_id: String) -> Vec<Transaction> {
     vec![
         transaction_builder.register_service_with_random_keys(&service_id).commit(),
         transaction_builder
-            .create_account_with_random_key("user1@example.com", &service_id)
+            .create_account_with_random_key_signed("user1@example.com", &service_id)
             .commit(),
         transaction_builder
-            .create_account_with_random_key("user2@example.com", &service_id)
+            .create_account_with_random_key_signed("user2@example.com", &service_id)
             .commit(),
         transaction_builder.add_random_key_verified_with_root("user1@example.com").commit(),
     ]
@@ -54,8 +54,9 @@ async fn test_process_transactions() {
     let mut transaction_builder = TransactionBuilder::new();
     let register_service_transaction =
         transaction_builder.register_service_with_random_keys("test_service").commit();
-    let create_account_transaction =
-        transaction_builder.create_account_with_random_key("test_account", "test_service").commit();
+    let create_account_transaction = transaction_builder
+        .create_account_with_random_key_signed("test_account", "test_service")
+        .commit();
 
     let proof = prover.process_transaction(register_service_transaction).await.unwrap();
     assert!(matches!(proof, Proof::Insert(_)));
@@ -96,7 +97,7 @@ async fn test_execute_block_with_invalid_tx() {
 
     let transactions = vec![
         tx_builder.register_service_with_random_keys("service_id").commit(),
-        tx_builder.create_account_with_random_key("account_id", "service_id").commit(),
+        tx_builder.create_account_with_random_key_signed("account_id", "service_id").commit(),
         // add new key, so it will be index = 1
         tx_builder.add_key_verified_with_root("account_id", new_key_vk.clone()).commit(),
         // revoke new key again

crates/tests/src/lib.rs

@@ -91,7 +91,7 @@ async fn test_light_client_prover_talking() -> Result<()> {
             for _ in 0..num_new_accounts {
                 let random_user_id = format!("{}@gmail.com", i);
                 let new_acc = transaction_builder
-                    .create_account_with_random_key(random_user_id.as_str(), "test_service")
+                    .create_account_with_random_key_signed(random_user_id.as_str(), "test_service")
                     .commit();
                 match prover.clone().validate_and_queue_update(new_acc).await {
                     Ok(_) => {