Merge origin/develop into anthony/arm-crate-split

Resolved conflicts in arm/src/action.rs and arm/src/transaction.rs:
- action.rs: dropped develop's duplicate verify/delta/get_delta_msg methods
  (already provided by ActionExt trait); changed verify signature to &self
- transaction.rs: kept crate-split architecture (DeltaProof::from_bytes,
  non-Result get_delta_msg); changed verify signature to &self to match
- delta_proof.rs: auto-merged (mod tests reorganization)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: XuyangSong

arm/src/action.rs

@@ -23,7 +23,7 @@ pub trait ActionExt {
         Self: Sized;
 
     /// Verifies all proofs and consistencies in the action.
-    fn verify(self) -> Result<(), ArmError>;
+    fn verify(&self) -> Result<(), ArmError>;
 
     /// This function computes the delta of the action by summing up the deltas
     /// of each compliance unit.
@@ -48,7 +48,7 @@ impl ActionExt for Action {
         })
     }
 
-    fn verify(self) -> Result<(), ArmError> {
+    fn verify(&self) -> Result<(), ArmError> {
         for unit in &self.compliance_units {
             unit.verify()?;
         }

arm/src/delta_proof.rs

@@ -221,20 +221,49 @@ impl<'de> Deserialize<'de> for DeltaWitness {
     }
 }
 
-#[test]
-fn test_delta_proof() {
+#[cfg(test)]
+mod tests {
+    use super::*;
     use k256::elliptic_curve::rand_core::OsRng;
 
-    let mut rng = OsRng;
-    let signing_key = SigningKey::random(&mut rng);
-    let verifying_key = VerifyingKey::from(&signing_key);
+    #[test]
+    fn test_delta_proof() {
+        let mut rng = OsRng;
+        let signing_key = SigningKey::random(&mut rng);
+        let verifying_key = VerifyingKey::from(&signing_key);
 
-    let message = b"Hello, world!";
-    let witness = DeltaWitness { signing_key };
-    let proof = DeltaProof::prove(message, &witness).unwrap();
-    let instance = DeltaInstance { verifying_key };
+        let message = b"Hello, world!";
+        let witness = DeltaWitness { signing_key };
+        let proof = DeltaProof::prove(message, &witness).unwrap();
+        let instance = DeltaInstance { verifying_key };
+
+        DeltaProof::verify(message, &proof, instance).unwrap();
+    }
+
+    /// DeltaProof: serialize then deserialize via bincode must round-trip.
+    #[test]
+    fn delta_proof_bincode_roundtrip() {
+        let mut rng = OsRng;
+        let signing_key = SigningKey::random(&mut rng);
+        let witness = DeltaWitness { signing_key };
+        let proof = DeltaProof::prove(b"roundtrip", &witness).unwrap();
+
+        let encoded = bincode::serialize(&proof).unwrap();
+        let decoded: DeltaProof = bincode::deserialize(&encoded).unwrap();
+        assert_eq!(proof, decoded);
+    }
 
-    DeltaProof::verify(message, &proof, instance).unwrap();
+    /// DeltaWitness: serialize then deserialize via bincode must round-trip.
+    #[test]
+    fn delta_witness_bincode_roundtrip() {
+        let mut rng = OsRng;
+        let signing_key = SigningKey::random(&mut rng);
+        let witness = DeltaWitness { signing_key };
+
+        let encoded = bincode::serialize(&witness).unwrap();
+        let decoded: DeltaWitness = bincode::deserialize(&encoded).unwrap();
+        assert_eq!(witness, decoded);
+    }
 }
 
 /// DeltaProof: serialize then deserialize via bincode must round-trip.

arm/src/transaction.rs

@@ -31,7 +31,7 @@ pub trait TransactionExt {
     fn generate_delta_proof(self) -> Result<Transaction, ArmError>;
 
     /// Verifies all the proofs and corresponding checks in the transaction.
-    fn verify(self) -> Result<(), ArmError>;
+    fn verify(&self) -> Result<(), ArmError>;
 
     /// Returns the DeltaInstance constructed from the sum of all actions' deltas.
     fn delta(&self) -> Result<DeltaInstance, ArmError>;
@@ -88,7 +88,7 @@ impl TransactionExt for Transaction {
         }
     }
 
-    fn verify(self) -> Result<(), ArmError> {
+    fn verify(&self) -> Result<(), ArmError> {
         match &self.delta_proof {
             Delta::Proof(proof) => {
                 let proof = DeltaProof::from_bytes(&proof.0)?;
@@ -109,7 +109,7 @@ impl TransactionExt for Transaction {
                     self.verify_aggregation()?;
                 } else {
                     // Try verifying individually.
-                    for action in self.actions {
+                    for action in self.actions.iter() {
                         action.verify()?;
                     }
                 }