Merge pull request #25 from anoma/xuyang/complete_the_tx

add the transaction verification and tests

Author: XuyangSong

native/aarm/Cargo.toml

@@ -11,6 +11,8 @@ risc0-zkvm = { version = "1.1.2" }
 serde = { version = "1.0.197", default-features = false }
 compliance_circuit = { path = "../examples/compliance_circuit/methods", package = 'methods'}
 aarm_core = { path = "../aarm_core" }
+k256 = { version = "=0.13.1", features = ["arithmetic", "serde", "expose-field", "std", "ecdsa", "hash2curve"], default-features = false }
+
 
 [dev-dependencies]
 bincode = "1.3"

native/aarm/src/action.rs

@@ -1,4 +1,6 @@
+use aarm_core::compliance::ComplianceInstance;
 use compliance_circuit::COMPLIANCE_GUEST_ID;
+use k256::ProjectivePoint;
 use risc0_zkvm::Receipt;
 use serde::{Deserialize, Serialize};
 
@@ -43,36 +45,68 @@ impl Action {
 
         true
     }
+
+    pub fn get_delta(&self) -> Vec<ProjectivePoint> {
+        self.compliance_units
+            .iter()
+            .map(|receipt| {
+                let instance: ComplianceInstance = receipt.journal.decode().unwrap();
+                instance.delta_projective()
+            })
+            .collect()
+    }
+
+    pub fn get_delta_msg(&self) -> Vec<u8> {
+        let mut msg = Vec::new();
+        for receipt in &self.compliance_units {
+            let instance: ComplianceInstance = receipt.journal.decode().unwrap();
+            msg.extend_from_slice(&instance.delta_msg());
+        }
+        msg
+    }
 }
 
-#[test]
-fn test_action() {
-    use aarm_core::{compliance::ComplianceWitness, constants::TREE_DEPTH, utils::GenericEnv};
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+    use aarm_core::{
+        compliance::ComplianceWitness, constants::TREE_DEPTH, delta_proof::DeltaWitness,
+        utils::GenericEnv,
+    };
     use bincode;
     use compliance_circuit::COMPLIANCE_GUEST_ELF;
     use risc0_zkvm::{default_prover, ExecutorEnv};
     use serde_bytes::ByteBuf;
 
-    let compliance_witness: ComplianceWitness<TREE_DEPTH> =
-        ComplianceWitness::<TREE_DEPTH>::default();
-    let generic_env = GenericEnv {
-        data: ByteBuf::from(bincode::serialize(&compliance_witness).unwrap()),
-    };
+    pub fn create_an_action() -> (Action, DeltaWitness) {
+        let compliance_witness: ComplianceWitness<TREE_DEPTH> =
+            ComplianceWitness::<TREE_DEPTH>::default();
+        let generic_env = GenericEnv {
+            data: ByteBuf::from(bincode::serialize(&compliance_witness).unwrap()),
+        };
 
-    let env = ExecutorEnv::builder()
-        .write(&generic_env)
-        .unwrap()
-        .build()
-        .unwrap();
+        let env = ExecutorEnv::builder()
+            .write(&generic_env)
+            .unwrap()
+            .build()
+            .unwrap();
 
-    let prover = default_prover();
+        let prover = default_prover();
 
-    let receipt = prover.prove(env, COMPLIANCE_GUEST_ELF).unwrap().receipt;
+        let receipt = prover.prove(env, COMPLIANCE_GUEST_ELF).unwrap().receipt;
 
-    let compliance_units = vec![receipt.clone()];
-    let logic_proofs = vec![receipt];
+        let compliance_units = vec![receipt.clone()];
+        let logic_proofs = vec![receipt];
 
-    let action = Action::new(compliance_units, logic_proofs);
+        let action = Action::new(compliance_units, logic_proofs);
+        assert!(action.verify());
 
-    assert!(action.verify());
+        let delta_witness = DeltaWitness::from_scalars(&[compliance_witness.rcv]);
+        (action, delta_witness)
+    }
+
+    #[test]
+    fn test_action() {
+        let _ = create_an_action();
+    }
 }

native/aarm/src/transaction.rs

@@ -53,10 +53,39 @@ impl Transaction {
     }
 
     pub fn get_delta_instance(&self) -> DeltaInstance {
-        unimplemented!()
+        let deltas = self
+            .action
+            .iter()
+            .flat_map(|action| action.get_delta())
+            .collect::<Vec<_>>();
+        DeltaInstance::from_deltas(&deltas).unwrap()
     }
 
     pub fn get_delta_msg(&self) -> Vec<u8> {
-        unimplemented!()
+        let mut msg = Vec::new();
+        for action in &self.action {
+            msg.extend(action.get_delta_msg());
+        }
+        msg
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::action::tests::create_an_action;
+
+    pub fn generate_test_transaction() -> Transaction {
+        let (action, delta_witness) = create_an_action();
+        let mut tx = Transaction::new(vec![action], Delta::Witness(delta_witness));
+        tx.generate_delta_proof();
+        assert!(tx.verify());
+
+        tx
+    }
+
+    #[test]
+    fn test_transaction() {
+        let _ = generate_test_transaction();
     }
 }

native/aarm_core/src/compliance.rs

@@ -140,4 +140,11 @@ impl ComplianceInstance {
     pub fn delta_projective(&self) -> ProjectivePoint {
         ProjectivePoint::from_encoded_point(&self.delta).unwrap()
     }
+
+    pub fn delta_msg(&self) -> Vec<u8> {
+        let mut msg = Vec::new();
+        msg.extend_from_slice(self.nullifier.as_bytes());
+        msg.extend_from_slice(self.commitment.as_bytes());
+        msg
+    }
 }