Merge pull request #24 from anoma/xuyang/fix_delta_format

fix delta format

Author: XuyangSong

native/aarm/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "aarm"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+# If you want to try (experimental) std support, add `features = [ "std" ]` to risc0-zkvm
+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"

native/aarm/src/action.rs

@@ -0,0 +1,78 @@
+use compliance_circuit::COMPLIANCE_GUEST_ID;
+use risc0_zkvm::Receipt;
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct Action {
+    pub compliance_units: Vec<Receipt>,
+    pub logic_proofs: Vec<Receipt>,
+}
+
+impl Action {
+    pub fn new(compliance_units: Vec<Receipt>, logic_proofs: Vec<Receipt>) -> Self {
+        Action {
+            compliance_units,
+            logic_proofs,
+        }
+    }
+
+    pub fn get_compliance_units(&self) -> &Vec<Receipt> {
+        &self.compliance_units
+    }
+
+    pub fn get_logic_proofs(&self) -> &Vec<Receipt> {
+        &self.logic_proofs
+    }
+
+    pub fn verify(&self) -> bool {
+        for receipt in &self.compliance_units {
+            if receipt.verify(COMPLIANCE_GUEST_ID).is_err() {
+                return false;
+            }
+        }
+
+        // TODO: Verify real logic proofs
+        for receipt in &self.logic_proofs {
+            if receipt.verify(COMPLIANCE_GUEST_ID).is_err() {
+                return false;
+            }
+        }
+
+        // TODO: Verify other checks
+        // Actually, the verification should occur on validators/EVM adapter.
+
+        true
+    }
+}
+
+#[test]
+fn test_action() {
+    use aarm_core::{compliance::ComplianceWitness, constants::TREE_DEPTH, 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()),
+    };
+
+    let env = ExecutorEnv::builder()
+        .write(&generic_env)
+        .unwrap()
+        .build()
+        .unwrap();
+
+    let prover = default_prover();
+
+    let receipt = prover.prove(env, COMPLIANCE_GUEST_ELF).unwrap().receipt;
+
+    let compliance_units = vec![receipt.clone()];
+    let logic_proofs = vec![receipt];
+
+    let action = Action::new(compliance_units, logic_proofs);
+
+    assert!(action.verify());
+}

native/aarm/src/lib.rs

@@ -0,0 +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/authorization.rs

@@ -0,0 +1,89 @@
+use k256::ecdsa::{
+    signature::{Signer, Verifier},
+    Error, Signature, SigningKey, VerifyingKey,
+};
+use k256::{elliptic_curve::rand_core::OsRng, EncodedPoint};
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone)]
+pub struct AuthorizationSigningKey(SigningKey);
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct AuthorizationVerifyingKey(EncodedPoint);
+
+#[derive(Clone, Serialize, Deserialize)]
+pub struct AuthorizationSignature(Signature);
+
+impl AuthorizationSigningKey {
+    pub fn new() -> Self {
+        let signing_key = SigningKey::random(&mut OsRng);
+        AuthorizationSigningKey(signing_key)
+    }
+
+    pub fn sign(&self, message: &[u8]) -> AuthorizationSignature {
+        AuthorizationSignature(self.0.sign(message))
+    }
+
+    pub fn to_bytes(&self) -> [u8; 32] {
+        self.0.to_bytes().into()
+    }
+
+    pub fn from_bytes(bytes: &[u8]) -> Self {
+        AuthorizationSigningKey(SigningKey::from_bytes(bytes.into()).unwrap())
+    }
+}
+
+impl Default for AuthorizationSigningKey {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Serialize for AuthorizationSigningKey {
+    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 AuthorizationSigningKey {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let bytes = <[u8; 32]>::deserialize(deserializer)?;
+        Ok(AuthorizationSigningKey::from_bytes(&bytes))
+    }
+}
+
+impl AuthorizationVerifyingKey {
+    pub fn from_signing_key(signing_key: &AuthorizationSigningKey) -> Self {
+        let verifying_key = signing_key.0.verifying_key();
+        AuthorizationVerifyingKey(verifying_key.to_encoded_point(false))
+    }
+
+    pub fn verify(&self, message: &[u8], signature: &AuthorizationSignature) -> Result<(), Error> {
+        VerifyingKey::from_encoded_point(&self.0)
+            .unwrap()
+            .verify(message, signature.inner())
+    }
+}
+
+impl AuthorizationSignature {
+    pub fn inner(&self) -> &Signature {
+        &self.0
+    }
+}
+
+#[test]
+fn test_authorization() {
+    let signing_key = AuthorizationSigningKey::new();
+    let verifying_key = AuthorizationVerifyingKey::from_signing_key(&signing_key);
+
+    let message = b"Hello, world!";
+    let signature = signing_key.sign(message);
+
+    assert!(verifying_key.verify(message, &signature).is_ok());
+}

native/aarm_core/src/compliance.rs

@@ -1,12 +1,13 @@
 use crate::{
-    constants::{DEFAULT_BYTES, TRIVIAL_RESOURCE_LOGIC_VK},
-    merkle_path::MerklePath,
-    nullifier_key::NullifierKey,
+    constants::TRIVIAL_RESOURCE_LOGIC_VK, merkle_path::MerklePath, nullifier_key::NullifierKey,
     resource::Resource,
 };
 use k256::{
-    elliptic_curve::{group::GroupEncoding, Field},
-    ProjectivePoint, Scalar,
+    elliptic_curve::{
+        sec1::{FromEncodedPoint, ToEncodedPoint},
+        Field,
+    },
+    EncodedPoint, ProjectivePoint, Scalar,
 };
 use rand::Rng;
 use risc0_zkvm::sha::{Digest, Impl, Sha256};
@@ -17,7 +18,7 @@ pub struct ComplianceInstance {
     pub nullifier: Digest,
     pub commitment: Digest,
     pub merkle_root: Digest,
-    pub delta: [u8; DEFAULT_BYTES],
+    pub delta: EncodedPoint,
     pub consumed_logic_ref: Digest,
     pub created_logic_ref: Digest,
 }
@@ -117,17 +118,26 @@ impl<const COMMITMENT_TREE_DEPTH: usize> ComplianceCircuit<COMMITMENT_TREE_DEPTH
         MerklePath::from_path(self.compliance_witness.merkle_path).root(cm)
     }
 
-    pub fn delta_commitment(&self) -> [u8; DEFAULT_BYTES] {
+    pub fn delta_commitment(&self) -> EncodedPoint {
         // Compute delta and make delta commitment public
         let delta = self.compliance_witness.consumed_resource.kind()
             * self.compliance_witness.consumed_resource.quantity_scalar()
             - self.compliance_witness.created_resource.kind()
                 * self.compliance_witness.created_resource.quantity_scalar()
             + ProjectivePoint::GENERATOR * self.compliance_witness.rcv;
 
-        let delta_bytes: [u8; DEFAULT_BYTES] = delta.to_affine().to_bytes()[..DEFAULT_BYTES]
-            .try_into()
-            .expect("Slice length mismatch");
-        delta_bytes
+        delta.to_encoded_point(false)
+    }
+}
+
+impl ComplianceInstance {
+    pub fn delta_coordinates(&self) -> ([u8; 32], [u8; 32]) {
+        let x = (*self.delta.x().unwrap()).into();
+        let y = (*self.delta.y().unwrap()).into();
+        (x, y)
+    }
+
+    pub fn delta_projective(&self) -> ProjectivePoint {
+        ProjectivePoint::from_encoded_point(&self.delta).unwrap()
     }
 }

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;