feat: hooks, split arkworks backend

Author: markosg04

README.md

@@ -37,8 +37,13 @@ Dory is a transparent polynomial commitment scheme with excellent asymptotic per
 
 ### Backend Implementations
 
-- **`backends::arkworks`** - Arkworks backend with BN254 curve (requires `arkworks` feature)
-- **`backends::blake2b_transcript`** - Blake2b-based Fiat-Shamir transcript
+- **`backends::arkworks`** - Modular Arkworks backend with BN254 curve (requires `arkworks` feature)
+  - Field wrappers (`ArkFr`)
+  - Group wrappers (`ArkG1`, `ArkG2`, `ArkGT`)
+  - Polynomial implementation
+  - Optimized MSM routines
+  - Blake2b transcript
+  - Serialization bridge
 
 ## How It Works
 
@@ -105,6 +110,18 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 }
 ```
 
+## Development Setup
+
+After cloning the repository, install Git hooks to ensure code quality:
+
+```bash
+./scripts/install-hooks.sh
+```
+
+This installs a pre-commit hook that:
+- Auto-formats code with `cargo fmt`
+- Runs `cargo clippy` in strict mode
+
 ## Performance Considerations
 
 This implementation is optimized for performance:
@@ -149,8 +166,14 @@ src/
 │   ├── transcript.rs              # Fiat-Shamir transcript trait
 │   └── serialization.rs           # Serialization abstractions
 ├── backends/
-│   ├── arkworks.rs                # BN254 implementation
-│   └── blake2b_transcript.rs      # Blake2b transcript
+│   ├── mod.rs                     # Backend module exports
+│   └── arkworks/                  # Arkworks BN254 backend
+│       ├── mod.rs                 # Module exports
+│       ├── ark_field.rs           # Field wrapper (ArkFr)
+│       ├── ark_group.rs           # Group wrappers (ArkG1, ArkG2, ArkGT)
+│       ├── ark_poly.rs            # Polynomial implementation
+│       ├── ark_serde.rs           # Serialization bridge
+│       └── blake2b_transcript.rs  # Blake2b transcript
 ├── setup.rs                       # Transparent setup generation
 ├── evaluation_proof.rs            # Proof creation and verification
 ├── reduce_and_fold.rs             # Inner product protocol
@@ -159,6 +182,7 @@ src/
 └── error.rs                       # Error types
 
 tests/arkworks/
+├── mod.rs                         # Test utilities
 ├── setup.rs                       # Setup tests
 ├── commitment.rs                  # Commitment tests
 ├── evaluation.rs                  # Evaluation tests

hooks/pre-commit

@@ -0,0 +1,21 @@
+#!/bin/bash
+# Pre-commit hook for Dory
+# Runs cargo fmt (auto-fix) and cargo clippy (strict mode)
+
+set -e
+
+echo "Running pre-commit checks..."
+
+echo "  → Running cargo fmt..."
+cargo fmt --all
+
+git diff --name-only | grep '\.rs$' | xargs -r git add
+
+echo "  → Running cargo clippy (strict mode)..."
+if ! cargo clippy -q --message-format=short --all --all-targets --all-features -- -D warnings; then
+    echo "❌ Clippy failed with warnings or errors. Fix them before committing."
+    exit 1
+fi
+
+echo "✅ All pre-commit checks passed!"
+exit 0

scripts/install-hooks.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+# Installation script for Git hooks
+
+set -e
+
+HOOKS_DIR="hooks"
+GIT_HOOKS_DIR=".git/hooks"
+
+echo "Installing Git hooks..."
+
+# Check if we're in a git repository
+if [ ! -d ".git" ]; then
+    echo "Error: Not a git repository. Run this script from the repository root."
+    exit 1
+fi
+
+# Check if hooks directory exists
+if [ ! -d "$HOOKS_DIR" ]; then
+    echo "Error: hooks/ directory not found"
+    exit 1
+fi
+
+# Install pre-commit hook
+if [ -f "$HOOKS_DIR/pre-commit" ]; then
+    cp "$HOOKS_DIR/pre-commit" "$GIT_HOOKS_DIR/pre-commit"
+    chmod +x "$GIT_HOOKS_DIR/pre-commit"
+    echo "✅ Installed pre-commit hook"
+else
+    echo "⚠️  Warning: hooks/pre-commit not found"
+fi
+
+echo "Done! Git hooks are now active."
+echo ""
+echo "The pre-commit hook will:"
+echo "  • Auto-format code with cargo fmt"
+echo "  • Run cargo clippy in strict mode"
+echo "  • Block commits if clippy warnings exist"

src/backends/arkworks/ark_field.rs

@@ -0,0 +1,104 @@
+use crate::primitives::arithmetic::Field;
+use ark_bn254::Fr;
+use ark_ff::{Field as ArkField, UniformRand, Zero as ArkZero};
+use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
+use ark_std::ops::{Add, Mul, Neg, Sub};
+use rand_core::RngCore;
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, CanonicalSerialize, CanonicalDeserialize)]
+pub struct ArkFr(pub Fr);
+
+impl Field for ArkFr {
+    fn zero() -> Self {
+        ArkFr(Fr::from(0u64))
+    }
+
+    fn one() -> Self {
+        ArkFr(Fr::from(1u64))
+    }
+
+    fn is_zero(&self) -> bool {
+        ArkZero::is_zero(&self.0)
+    }
+
+    fn add(&self, rhs: &Self) -> Self {
+        ArkFr(self.0 + rhs.0)
+    }
+
+    fn sub(&self, rhs: &Self) -> Self {
+        ArkFr(self.0 - rhs.0)
+    }
+
+    fn mul(&self, rhs: &Self) -> Self {
+        ArkFr(self.0 * rhs.0)
+    }
+
+    fn inv(self) -> Option<Self> {
+        ArkField::inverse(&self.0).map(ArkFr)
+    }
+
+    fn random<R: RngCore>(rng: &mut R) -> Self {
+        ArkFr(Fr::rand(rng))
+    }
+
+    fn from_u64(val: u64) -> Self {
+        ArkFr(Fr::from(val))
+    }
+
+    fn from_i64(val: i64) -> Self {
+        if val >= 0 {
+            ArkFr(Fr::from(val as u64))
+        } else {
+            ArkFr(-Fr::from((-val) as u64))
+        }
+    }
+}
+
+impl Add for ArkFr {
+    type Output = Self;
+    fn add(self, rhs: Self) -> Self {
+        ArkFr(self.0 + rhs.0)
+    }
+}
+
+impl Sub for ArkFr {
+    type Output = Self;
+    fn sub(self, rhs: Self) -> Self {
+        ArkFr(self.0 - rhs.0)
+    }
+}
+
+impl Mul for ArkFr {
+    type Output = Self;
+    fn mul(self, rhs: Self) -> Self {
+        ArkFr(self.0 * rhs.0)
+    }
+}
+
+impl Neg for ArkFr {
+    type Output = Self;
+    fn neg(self) -> Self {
+        ArkFr(-self.0)
+    }
+}
+
+impl<'a> Add<&'a ArkFr> for ArkFr {
+    type Output = ArkFr;
+    fn add(self, rhs: &'a ArkFr) -> ArkFr {
+        ArkFr(self.0 + rhs.0)
+    }
+}
+
+impl<'a> Sub<&'a ArkFr> for ArkFr {
+    type Output = ArkFr;
+    fn sub(self, rhs: &'a ArkFr) -> ArkFr {
+        ArkFr(self.0 - rhs.0)
+    }
+}
+
+impl<'a> Mul<&'a ArkFr> for ArkFr {
+    type Output = ArkFr;
+    fn mul(self, rhs: &'a ArkFr) -> ArkFr {
+        ArkFr(self.0 * rhs.0)
+    }
+}