add the transaction struct

Author: XuyangSong

native/aarm/Cargo.toml

@@ -10,8 +10,8 @@ edition = "2021"
 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" }
 
 [dev-dependencies]
 bincode = "1.3"
-serde_bytes = "0.11"
-aarm_core = { path = "../aarm_core" }
+serde_bytes = "0.11"

native/aarm/src/lib.rs

@@ -1 +1,2 @@
 pub mod action;
+pub mod transaction;

native/aarm/src/transaction.rs

@@ -0,0 +1,62 @@
+use crate::action::Action;
+use aarm_core::delta_proof::{DeltaInstance, DeltaProof, DeltaWitness};
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct Transaction {
+    pub action: Vec<Action>,
+    pub delta_proof: Delta,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub enum Delta {
+    Witness(DeltaWitness),
+    Proof(DeltaProof),
+}
+
+impl Transaction {
+    pub fn new(action: Vec<Action>, delta: Delta) -> Self {
+        Transaction {
+            action,
+            delta_proof: delta,
+        }
+    }
+
+    pub fn generate_delta_proof(&mut self) {
+        match self.delta_proof {
+            Delta::Witness(ref witness) => {
+                let msg = self.get_delta_msg();
+                let proof = DeltaProof::prove(&msg, witness);
+                self.delta_proof = Delta::Proof(proof);
+            }
+            Delta::Proof(_) => {}
+        }
+    }
+
+    pub fn verify(&self) -> bool {
+        match &self.delta_proof {
+            Delta::Proof(ref proof) => {
+                let msg = self.get_delta_msg();
+                let instance = self.get_delta_instance();
+                if DeltaProof::verify(&msg, proof, instance).is_err() {
+                    return false;
+                }
+                for action in &self.action {
+                    if !action.verify() {
+                        return false;
+                    }
+                }
+                true
+            }
+            Delta::Witness(_) => false,
+        }
+    }
+
+    pub fn get_delta_instance(&self) -> DeltaInstance {
+        unimplemented!()
+    }
+
+    pub fn get_delta_msg(&self) -> Vec<u8> {
+        unimplemented!()
+    }
+}

native/aarm_core/src/delta_proof.rs

@@ -1,12 +1,15 @@
 use k256::ecdsa::{Error, RecoveryId, Signature, SigningKey, VerifyingKey};
 use k256::{elliptic_curve::ScalarPrimitive, ProjectivePoint, PublicKey, Scalar, SecretKey};
+use serde::{Deserialize, Serialize};
 use sha3::{Digest, Keccak256};
 
+#[derive(Clone, Debug)]
 pub struct DeltaProof {
     pub signature: Signature,
     pub recid: RecoveryId,
 }
 
+#[derive(Clone, Debug)]
 pub struct DeltaWitness {
     pub signing_key: SigningKey,
 }
@@ -79,6 +82,13 @@ impl DeltaWitness {
     pub fn to_bytes(&self) -> [u8; 32] {
         self.signing_key.to_bytes().into()
     }
+
+    pub fn compose(&mut self, other: &DeltaWitness) {
+        let sum = self.signing_key.as_nonzero_scalar().as_ref()
+            + other.signing_key.as_nonzero_scalar().as_ref();
+        let sk: SecretKey = SecretKey::new(sum.into());
+        self.signing_key = SigningKey::from(sk);
+    }
 }
 
 impl DeltaInstance {
@@ -92,6 +102,49 @@ impl DeltaInstance {
     }
 }
 
+impl Serialize for DeltaProof {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_bytes(&self.to_bytes())
+    }
+}
+
+impl<'de> Deserialize<'de> for DeltaProof {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let bytes: Vec<u8> = serde_bytes::deserialize(deserializer)?;
+        if bytes.len() != 65 {
+            return Err(serde::de::Error::custom(
+                "Invalid byte length for DeltaProof",
+            ));
+        }
+        Ok(DeltaProof::from_bytes(&bytes))
+    }
+}
+
+impl Serialize for DeltaWitness {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_bytes(&self.to_bytes())
+    }
+}
+
+impl<'de> Deserialize<'de> for DeltaWitness {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let bytes = <[u8; 32]>::deserialize(deserializer)?;
+        Ok(DeltaWitness::from_bytes(&bytes))
+    }
+}
+
 #[test]
 fn test_delta_proof() {
     use k256::elliptic_curve::rand_core::OsRng;