Update Milestone 3

.github/workflows/ci_cd.yml

@@ -0,0 +1,62 @@
+name: CI
+on:
+  workflow_dispatch:
+
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+      - feature/keygen_aux
+
+jobs:
+  build:
+    name: Build and Test
+    runs-on: ubuntu-latest
+
+    steps:
+      # Step 1: Checkout the repository
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      # Step 2: Set up JDK for Kotlin
+      - name: Set up JDK
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'temurin'
+          java-version: 11
+
+      # Step 3: Cache Gradle dependencies
+      - name: Cache Gradle dependencies
+        uses: actions/cache@v3
+        with:
+          path: ~/.gradle/caches
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+
+      # Step 4: Build the project
+      - name: Build project
+        run: ./gradlew build
+
+      # Step 5: Run tests with code coverage verification
+      - name: Run tests and verify coverage
+        run: ./gradlew test
+
+      # Step 6: Generate code coverage report
+      - name: Generate code coverage report
+        run: ./gradlew jacocoTestReport
+
+      # Step 7: Upload code coverage report as artifact
+      - name: Generate Coverage Badge
+        uses: cicirello/jacoco-badge-generator@v2
+        with:
+            jacoco-csv-file: build/reports/jacoco/test/jacocoTestReport.csv
+            badges-directory: build/reports/jacoco/test/html/badges
+
+      - name: Publish coverage report to GitHub Pages
+        # if: ${{ github.ref == 'refs/heads/master' }}
+        uses: JamesIves/github-pages-deploy-action@v4
+        with:
+            folder: build/reports/jacoco/test/html

README.md

@@ -1,7 +1,12 @@
 # Threshold ECDSA Signature
 
+[![Test Coverage](https://github.com/perun-network/ecdsa-threshold/blob/gh-pages/badges/jacoco.svg?raw=true)](https://perun-network.github.io/ecdsa-threshold/)
+[![CI](https://github.com/perun-network/ecdsa-threshold/actions/workflows/ci_cd.yml/badge.svg?branch=keygen)](https://github.com/perun-network/ecdsa-threshold/actions/workflows/ci_cd.yml)
+[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
 This project implements the threshold ECDSA protocol by [Canetti et al.](https://eprint.iacr.org/2021/060) (2021) that achieves non-interactive signing using 3 preprocessing rounds. 
 It further provides malicious security and identifiable aborts.
+
 We provide an implementation of the protocol in Kotlin using the secp256k1 elliptic curve.
 
 The report on threshold ECDSA signatures for Atala PRISM and the project timeline can be found in the [Wiki](https://github.com/perun-network/atala-prism-threshold/wiki/Threshold-ECDSA-Signatures-for-Atala-PRISM-Report).
@@ -13,6 +18,7 @@ The report on threshold ECDSA signatures for Atala PRISM and the project timelin
 - [Requirements](#requirements)
 - [Installation](#installation)
 - [Usage](#usage)
+- [Test](#test)
 - [Code Structure](#code-structure)
 - [Limitations](#limitations)
 - [Copyright](#copyright)
@@ -21,38 +27,40 @@ The report on threshold ECDSA signatures for Atala PRISM and the project timelin
 
 - Threshold ECDSA signing with preprocessing, where subsets of t signers can create signatures in one round.
 - Implementation of the Paillier encryption scheme and Pedersen commitments.
-- Zero-knowledge proofs for Paillier encryptions, which are during the signing process.
+- Zero-knowledge proofs to prove the validity of computations along the execution of the protocol.
 - The protocol can be integrated to [Apollo](https://github.com/hyperledger/identus-apollo) to be used in crypto services and the threshold Signature can be translated to Apollo's ECDSA Secp256k1 implementation.
 
 ## Architecture
 
 The project is structured into several packages:
 
 - **`ecdsa`**: Core ECDSA functionalities and mathematical operations.
-- **`keygen`**: Key generation and precomputation.
+- **`precomp`**: Centralized key generation and precomputation.
 - **`math`**: Mathematical operations and utilities used throughout the signing process.
 - **`paillier`**: Implementation of the Paillier cryptosystem for encryption.
 - **`pedersen`**: Pedersen commitment scheme with parameter generation.
-- **`presign`**: Management of the presigning process, including rounds of communication and computations between signers.
 - **`sign`**: Signing process management and partial signature combination.
+  - **`keygen`**: 3-round Key generation protocol.
+  - **`aux`**: 3-round key refresh/auxiliary-info protocol.
+  - **`presign`**: 3-round presigning protocol.
 - **`zero_knowledge`**: Zero-knowledge proof implementations.
 
 ## Requirements
 
 - Kotlin 1.5 or higher
-- Java Development Kit (JDK) 8 or higher
+- Java Development Kit (JDK) 11 or higher
 - Dependencies for cryptographic operations (included in the project)
 
 ## Installation
 
 1. **Clone the Repository**:
     ```bash
-       git clone https://github.com/yourusername/ecdsa-threshold-signing.git
+       git clone https://github.com/perun-network/atala-prism-threshold.git
     ```
 
 2. **Navigate to the Project Directory**:
     ```bash
-    cd ecdsa-threshold-signing
+    cd ecdsa-threshold
     ```
 
 3. **Build the Project**:
@@ -73,29 +81,75 @@ The main entry point for the threshold signing process is located in the `main`
 
 The application will output the execution time and confirm if the ECDSA signature was generated and verified successfully.
 
+## Test
+This section describes the testing strategy and tools used to maintain code quality and reliability.
+
+### Testing Frameworks and Tools
+- **Framework**: The project uses [JUnit 5](https://junit.org/junit5/) for unit and integration testing.
+- **Build Tool Integration**: Tests are executed using Gradle's test task.
+
+### Unit Tests and Integration Tests.
+    - Test individual components (e.g., classes, functions) in isolation.
+    - Validate interactions between components.
+    - Located in `src/test/kotlin`.
+
+### Running Tests
+To execute tests locally:
+
+- **Run all tests**:
+    ```bash
+    ./gradlew test
+    ```
+- **Run a specific test class:
+    ```bash
+    ./gradlew test --tests <class_name>
+    ```
+### Test Coverage Report
+The project uses [JaCoCo](https://www.eclemma.org/jacoco/) to measure test coverage.
+
+1. Generate Coverage Report: Run the following command to generate the coverage report:
+    ```bash
+    ./gradlew jacocoTestReport
+    ```
+2. View the Report: The HTML report is available at:
+    ```bash
+    build/reports/jacoco/test/html/index.html
+    ```
+   or online at 
+[Test Report](https://perun-network.github.io/ecdsa-threshold/)
+
+3. Coverage Standards:
+   - Instruction coverage: 90% or higher.
+   - Branches coverage: 80% or higher
+   - Critical areas must be thoroughly covered.
+
 ## Code Structure
 - **`src`**: Contains all source code.
   - **`main`**: Contains main functionality.
     - **`ecdsa`**: Core functionalities.
-    - **`keygen`**: Key generation and precomputation.
+    - **`precomp`**: Centralized key generation and precomputation.
     - **`math`**: Mathematical operations and utilities.
     - **`paillier`**: Paillier cryptosystem implementation.
     - **`pedersen`**: Pedersen commitment management.
-    - **`presign`**: Presigning process management.
     - **`sign`**: Signing process management.
-    - **`zkproof`**: Zero-knowledge proof implementations.
+      - **`keygen`**: Keygen process management.
+      - **`aux`**: Aux-Info process management.
+      - **`presign`**: Presigning process management. 
+    - **`zero_knowledge`**: Zero-knowledge proof implementations.
 
   - **`test`**: Contains functionality test.
     - **`ecdsa`**: Contains unit test for the Secp256k1 ECDSA signatures. 
+    - **`math`**: Contains unit test for the `math` classes.
+    - **`paillier`**: Contains unit test for the Paillier encryption scheme.
+    - **`precomp`**: Contains unit test for the `precomputation` classes.
     - **`sign`**: Contains unit test for the signing of Threshold ECDSA.
     - **`zk`**: Contains unit test for zero-knowledge implementations.
 
 ## Limitations
 The current implementation is currently lacking some intended features:
 
-- Distributed key generation protocol by [Canetti et al.](https://eprint.iacr.org/2021/060) have not been fully implemented. (Currently centralized)
-- Missing key refresh and adversary identification protocols.
 - Main currently using precomputed secret primes to generate precomputations. This is to speed up the process. It is expected to have an accelerated prime generator incorporated in the precomputation phase. 
+- Parallelization of Broadcast communication.
 
 ---
 ## Copyright

build.gradle.kts

@@ -1,6 +1,7 @@
 plugins {
     kotlin("jvm") version "2.0.0"
     id("org.jetbrains.kotlin.plugin.serialization") version "2.0.20-RC2"
+    id("jacoco")
 }
 
 group = "perun_network.ecdsa_threshold"
@@ -11,9 +12,11 @@ repositories {
     maven("https://jitpack.io")
 }
 
+
 dependencies {
-// define the BOM and its version
+    // define the BOM and its version
     implementation(platform("org.kotlincrypto.hash:bom:0.5.3"))
+    implementation("org.kotlincrypto.hash:sha2")
     testImplementation(kotlin("test"))
     implementation(kotlin("stdlib"))
     implementation("org.jetbrains.kotlinx:kotlinx-serialization-cbor:1.7.1")
@@ -22,13 +25,38 @@ dependencies {
     implementation("org.jetbrains.kotlin:kotlin-reflect:1.5.0")
     implementation("fr.acinq.secp256k1:secp256k1-kmp:0.15.0")
     implementation("fr.acinq.secp256k1:secp256k1-kmp-jni-jvm:0.15.0")
-    implementation("org.kotlincrypto.hash:sha2")
+
     implementation("com.ionspin.kotlin:bignum:0.3.8")
+    // Add Kotlin Logging
+    implementation("io.github.microutils:kotlin-logging:3.0.5")
+    implementation("ch.qos.logback:logback-classic:1.4.11")
+
 }
 
 tasks.test {
     useJUnitPlatform()
 }
 kotlin {
     jvmToolchain(11)
-}
+}
+
+
+jacoco {
+    toolVersion = "0.8.10" // Adjust to the latest JaCoCo version
+}
+
+tasks.jacocoTestReport {
+    reports {
+        csv.required.set(true)
+        xml.required.set(true) // Generate XML report
+        html.required.set(true) // Generate HTML report
+    }
+    classDirectories.setFrom(files(classDirectories.files.map {
+        fileTree(it) {
+            setExcludes(listOf(
+                "**/MainKt.class",
+                "perun_network/ecdsa_threshold/tuple/*",
+            ))
+        }
+    }))
+}