add simulated blockchain

Author: Pluck3dEye

.gitignore

@@ -0,0 +1,34 @@
+# Rust build artifacts
+/target/
+**/*.rs.bk
+
+# Cargo package files
+Cargo.lock
+
+# Node.js dependencies and build artifacts
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+package-lock.json
+
+# VSCode and JetBrains IDE settings
+.vscode/
+.idea/
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Byproducts
+*.log
+
+# Ignore compiled Lambda zips (if any)
+*.zip
+
+# Ignore dotenv files (if used)
+.env
+.env.*
+
+# Ignore test output
+*.out

Cargo.toml

@@ -7,6 +7,9 @@ edition = "2021"
 num-bigint = { version = "0.4", features = ["rand"] }
 num-traits = "0.2"
 rand = "0.8"
+reqwest = { version = "0.11", features = ["blocking", "json"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
 
 # Arkworks - all aligned to v0.4
 ark-ec = "0.4"

README.md

@@ -1,39 +1,81 @@
-
 # Vi-Anonymous-Credential
 
 This project implements a prototype of an anonymous credential issuance system using a bilinear pairing-based accumulator, designed to support an allow-list mechanism for revoking credentials and preventing misuse.
 
 The accumulator logic is currently being updated based on the model proposed by Flamini et al. (2025).
 👉 Read the paper here [https://eprint.iacr.org/2025/549.pdf]
 
-⸻
+---
 
-## 🔧 Project Components
+## Project Components
 
-### 🧩 Accumulator  
+### Accumulator  
 Represents the core bilinear pairing-based accumulator structure.  
 Includes logic for initializing, updating, and testing accumulator behavior via a simple `main` function.
 
-### 📜 Credential  
+### Credential  
 Defines a credential that includes:  
 - A BBS+ signature over a list of attribute values (messages).  
 - The issuer's public key.  
 This object models the credential held by the user.
 
-### 🔐 Commitment  
+### Commitment  
 Implements Pedersen-style commitments to hide sensitive message values.  
 Used during zero-knowledge proof generation to ensure privacy.
 
-### 🧾 Witness  
+### Witness  
 Contains the data a credential holder maintains to prove non-revocation:  
 - A private scalar `x`  
 - A Pedersen commitment `c_x`  
 - A trapdoor witness `w_x_t`  
 - The credential's BBS+ signature  
 
-⸻
+---
+
+## How to Test with the Blockchain
+
+1. **Start the Blockchain Server**
+
+   Open a terminal and run:
+   ```
+   node registry/blockchain_server.js
+   ```
+   You should see:
+   ```
+   Blockchain API running on port 3001
+   ```
+
+2. **Run the Rust Tests**
+
+   In another terminal, from the project root, run:
+   ```
+   cargo test --test issue_vc -- --nocapture
+   cargo test --test revoke_vc -- --nocapture
+   ```
+   This will:
+   - Issue a credential and log it to the blockchain.
+   - Revoke a credential and log the revocation to the blockchain.
+
+3. **Check the Blockchain Server Terminal**
+
+   You will see logs like:
+   ```
+   [ADD] Block added with data: "CredentialIssued:..."
+   [ADD] Block added with data: "CredentialRevoked:..."
+   [CHAIN] Chain requested
+   [VERIFY] Chain verification: true
+   ```
+
+4. **(Optional) Query the Blockchain API**
+
+   You can use `curl` or Postman to check the chain:
+   ```
+   curl http://localhost:3001/chain
+   ```
+
+---
 
-🚧 In Progress
-	•	Integration of the ZKP generation algorithm for the holder to prove validity and non-revocation of their credential.
+In Progress:
+- Integration of the ZKP generation algorithm for the holder to prove validity and non-revocation of their credential.
 
-⸻
+---

registry/README.md

@@ -0,0 +1,44 @@
+# How to Test with the Blockchain
+
+1. **Start the Blockchain Server**
+
+   Open a terminal in the `registry` folder and run:
+   ```
+   node blockchain_server.js
+   ```
+   You should see:
+   ```
+   Blockchain API running on port 3001
+   ```
+
+2. **Run the Rust Tests**
+
+   In a separate terminal, from the project root, run:
+   ```
+   cargo test --test issue_vc -- --nocapture
+   cargo test --test revoke_vc -- --nocapture
+   ```
+   This will:
+   - Issue a credential and add it to the blockchain.
+   - Revoke a credential and add the revocation to the blockchain.
+
+3. **Check Blockchain Server Output**
+
+   The blockchain server terminal will show logs like:
+   ```
+   [ADD] Block added with data: "CredentialIssued:..."
+   [ADD] Block added with data: "CredentialRevoked:..."
+   [CHAIN] Chain requested
+   [VERIFY] Chain verification: true
+   ```
+
+4. **(Optional) Query the Blockchain API**
+
+   You can check the blockchain state using:
+   ```
+   curl http://localhost:3001/chain
+   ```
+
+**Note:**  
+- The blockchain server must be running before you run the Rust tests.
+- Each test run will add new blocks to the blockchain.

registry/blockchain.js

@@ -0,0 +1,54 @@
+const crypto = require('crypto');
+
+class Block {
+  constructor(index, timestamp, data, prevHash) {
+    this.index = index;
+    this.timestamp = timestamp;
+    this.data = data;
+    this.prevHash = prevHash;
+    this.hash = this.computeHash();
+  }
+
+  computeHash() {
+    const str = this.index + this.timestamp + this.data + this.prevHash;
+    return crypto.createHash('sha256').update(str).digest('hex');
+  }
+}
+
+class Blockchain {
+  constructor() {
+    this.chain = [new Block(0, Date.now(), 'genesis', '0')];
+  }
+
+  addBlock(data) {
+    const prev = this.chain[this.chain.length - 1];
+    const block = new Block(
+      prev.index + 1,
+      Date.now(),
+      data,
+      prev.hash
+    );
+    this.chain.push(block);
+  }
+
+  verifyChain() {
+    for (let i = 1; i < this.chain.length; i++) {
+      const prev = this.chain[i - 1];
+      const curr = this.chain[i];
+      if (curr.prevHash !== prev.hash || curr.hash !== curr.computeHash()) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  getLatest() {
+    return this.chain[this.chain.length - 1];
+  }
+
+  findByData(data) {
+    return this.chain.find(b => b.data === data);
+  }
+}
+
+module.exports = { Block, Blockchain };

registry/blockchain_server.js

@@ -0,0 +1,26 @@
+const express = require('express');
+const { Blockchain } = require('./blockchain');
+const app = express();
+app.use(express.json());
+
+const chain = new Blockchain();
+
+app.post('/add', (req, res) => {
+  const { data } = req.body;
+  chain.addBlock(data);
+  console.log(`[ADD] Block added with data: ${JSON.stringify(data)}`);
+  res.json({ message: 'Block added' });
+});
+
+app.get('/chain', (req, res) => {
+  console.log(`[CHAIN] Chain requested`);
+  res.json(chain.chain);
+});
+
+app.get('/verify', (req, res) => {
+  const valid = chain.verifyChain();
+  console.log(`[VERIFY] Chain verification: ${valid}`);
+  res.json({ valid });
+});
+
+app.listen(3001, () => console.log('Blockchain API running on port 3001'));

registry/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "registry",
+  "version": "1.0.0",
+  "main": "blockchain.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "express": "^5.1.0"
+  }
+}

src/acumulator.rs

@@ -169,29 +169,27 @@ impl Accumulator {
     // remove an accumulated values - send the updated message for each holder to re-calculate their witness
 
     pub fn del(&mut self, sk: &SecretKey<Fr>, revoke_cred: Credential) -> Fr {
-
-            // Serialize the signature
-            let mut hasher = Sha256::new();
-            let mut sig_bytes = vec![];
-            revoke_cred.signature.serialize_compressed(&mut sig_bytes).unwrap();
-            hasher.update(sig_bytes);
-            let hash = hasher.finalize();
-            let cred_id = format!(
-                "cred_{}",
-                hash[..4].iter().map(|b| format!("{:02x}", b)).collect::<String>()
-            );
-
-            // Get x associated with this credential
-            let delta = *self.get_x_by_id(&cred_id).unwrap();
-            // let delta = self.issued_x.get(&cred_id).unwrap(); // Option<&Fr>
-            // the delta shall be stored in some-where for all un-update valid holder still work
-            let sum = delta + sk.0;
-            let inv = sum.inverse().unwrap();
-
-            // Update accumulator
-            self.acc_val = self.acc_val.mul(inv);
-
-            return delta;
+        // 1. Compute credential ID from signature
+        let mut hasher = Sha256::new();
+        let mut sig_bytes = vec![];
+        revoke_cred.signature.serialize_compressed(&mut sig_bytes).unwrap();
+        hasher.update(sig_bytes);
+        let hash = hasher.finalize();
+        let cred_id = format!(
+            "cred_{}",
+            hash[..4].iter().map(|b| format!("{:02x}", b)).collect::<String>()
+        );
+
+        // 2. Get x associated with this credential
+        let delta = *self.get_x_by_id(&cred_id).unwrap();
+
+        // 3. Update accumulator value to remove x
+        let sum = delta + sk.0;
+        let inv = sum.inverse().unwrap();
+        self.acc_val = self.acc_val.mul(inv);
+
+        // 4. Return the revoked x (delta)
+        return delta;
     }
 
     fn get_x_by_id(&self, cred_id: &str) -> Option<&Fr> {
@@ -209,7 +207,4 @@ impl Accumulator {
     pub fn get_parameter(&self) -> BBParams {
         self.parameter.clone().expect("Parameter of accumulator not been setup")
     }
-
-    
-    }
-
+}

src/main.rs

@@ -31,15 +31,20 @@ fn main() {
     let message_count = 2;
     let params = SignatureParamsG1::<Bls12_381>::generate_using_rng(&mut rng, message_count);
     let fr_messages: Vec<Fr> = (0..message_count).map(|_| Fr::rand(&mut rng)).collect();
+
+    // Step 4: Issuer creates a BBS+ signature over the holder's messages
     let signature = SignatureG1::new(&mut rng, &fr_messages, &sk, &params).unwrap();
 
-    // Step 4: Create credential
+    // Step 5: Issuer constructs the Credential object
     let credential = Credential {
         signature: signature.clone(),
         messages: fr_messages.clone(),
-        issuer_pk: None,
+        issuer_pk: None, // Optionally, set issuer_pk to Some(pk)
     };
 
+    // Step 6: Issuer delivers the credential to the holder
+    // (In practice, this would be sent securely to the holder)
+
     println!(
         "type of signature: {}",
         std::any::type_name_of_val(&credential.signature)
@@ -59,4 +64,19 @@ fn main() {
     // println!("\n[Test Case] Credential revoked");
     // println!("- delta (x) = {:?}", delta);
     // println!("- acc_val (after) = {:?}", acc.acc_val);
+
+    // --- Registry/Blockchain demo ---
+    // use registry::Blockchain;
+    // use std::time::{SystemTime, UNIX_EPOCH};
+
+    // let mut vdr = Blockchain::new();
+    // let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs();
+    // vdr.add_block("CredentialIssued:12345".to_string(), now);
+    // vdr.add_block("CredentialRevoked:12345".to_string(), now + 1);
+
+    // println!("\n[Registry] Blockchain state:");
+    // for block in &vdr.chain {
+    //     println!("{:?}", block);
+    // }
+    // println!("Chain valid? {}", vdr.verify_chain());
 }