feat: trait for signature and NCS impl over it

Cargo.toml

@@ -0,0 +1,14 @@
+[workspace]
+members = [
+  "h2s2",
+]
+
+
+[workspace.dependencies]
+ark-std = {version ="0.5.0", features = ["parallel"]}
+ark-ec = {version = "0.5.0", features = ["parallel"]}
+ark-ff = { version = "0.5", features = [ "parallel" ] }
+blake2 = "0.10.6"
+digest = "0.10.7"
+rayon = "1.1"
+ark-bn254 = "0.5.0"

h2s2/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "h2s2"
+version = "0.1.0"
+authors = [
+  "Bryan Cole <bryan.cole@semiotic.ai>",
+  "Severiano Sisneros <severiano@semiotic.ai>",
+  "Alexis Asseman <alexis@semiotic.ai>",
+  "Tomasz Kornuta <tomasz@semiotic.ai>",
+  "Pedro Bufulin <pedro@semiotic.ai>",
+]
+license = "Apache-2.0"
+description = ""
+edition = "2021"
+keywords = ["holographic", "homomorphic", "signature-scheme"]
+catagories = ["cryptography", "cryptography::cryptocurrencies"]
+
+[dependencies]
+ark-ec = {workspace = true}
+ark-std = { workspace = true}
+ark-ff = { workspace = true}
+ark-bn254 = { workspace = true}
+blake2 = {workspace = true}
+rayon = { workspace = true}
+digest = { workspace = true}
+once_cell = "1.20.2"

h2s2/src/holographic_homomorphic_signature_scheme.rs

@@ -0,0 +1,63 @@
+use ark_ec::pairing::Pairing;
+use ark_std::rand::Rng;
+use digest::Digest;
+use std::error::Error;
+
+pub trait HolographicHomomorphicSignatureScheme<P: Pairing, D: Digest + Send + Sync> {
+    type Parameters;
+    type PublicKey;
+    type SecretKey;
+    type Signature;
+    type Message;
+    type Weight;
+    type AggregatedSignature;
+
+    /// Generate one G2 element and `n` G1 elements
+    fn setup(n: usize) -> Result<Self::Parameters, Box<dyn Error>>;
+
+    /// Generate hash aggregate (H_a) with `tag` and `n` lanes, and a
+    /// allocation_id as a ScalarField
+    fn precompute(
+        pp: &Self::Parameters,
+        tag: P::ScalarField,
+        n: usize,
+    ) -> Result<(P::G1, P::ScalarField), Box<dyn Error>>;
+
+    /// Generate private and public receipt keys using `pp` parameters from `setup`
+    fn keygen<R: Rng>(
+        pp: &Self::Parameters,
+        rng: &mut R,
+    ) -> Result<(Self::PublicKey, Self::SecretKey), Box<dyn Error>>;
+
+    /// Sign `message` with `tag` at `index`
+    fn sign(
+        pp: &Self::Parameters,
+        tag: P::ScalarField,
+        index: usize,
+        message: Self::Message,
+    ) -> Result<Self::Signature, Box<dyn Error>>;
+
+    /// Verify a single `signature` matches `message` with `tag` at `index` using `pp` parameter and `pk` public key
+    ///  TODO: index should be restricted to a number from 1 to N (max number of lanes)
+    fn verify(
+        pp: &Self::Parameters,
+        tag: P::ScalarField,
+        index: usize,
+        message: &Self::Message,
+        signature: &Self::Signature,
+    ) -> Result<bool, Box<dyn Error>>;
+
+    /// Verify aggregate `signature` matches `message_aggregate`
+    /// contained in [`AggregatedSignature`] with `tag` and `hash_aggregate` using `pp` parameter and `pk` public key
+    fn verify_aggregate(
+        pp: &Self::Parameters,
+        hash_aggregate: &P::G1,
+        signature: &Self::AggregatedSignature,
+    ) -> Result<bool, Box<dyn Error>>;
+
+    /// Aggregate `signatures` with `weights`
+    fn evaluate(
+        signatures: &[Self::Signature],
+        weights: &[Self::Weight],
+    ) -> Result<Self::AggregatedSignature, Box<dyn Error>>;
+}

h2s2/src/lib.rs

@@ -0,0 +1,2 @@
+pub mod holographic_homomorphic_signature_scheme;
+pub mod ncs;