@zkclaw/credentials 1.0.0 → 1.0.1

package/package.json

@@ -1,21 +1,19 @@
 {
   "name": "@zkclaw/credentials",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "type": "module",
-  "main": "dist/index.js",
+  "main": "src/index.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js"
+      "import": "./src/index.ts",
+      "default": "./src/index.ts"
     }
   },
   "files": [
-    "dist",
-    "src/circuit/target/*.json"
+    "src/**/*"
   ],
   "scripts": {
     "build:circuit": "cd src/circuit && nargo compile && bb write_vk -b target/main.json -o target/vkey",
-    "build": "tsup src/index.ts --format esm --target node18",
-    "prepublishOnly": "bun run build",
     "test": "bun test",
     "test:circuit": "cd src/circuit && nargo test"
   },

package/src/circuit/Nargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "anon_balance"
+type = "bin"
+authors = ["anon"]
+compiler_version = ">=0.38.0"
+version = "0.1.0"
+
+[dependencies]
+lib = { path = "../noir-lib" }

package/src/circuit/src/main.nr

@@ -0,0 +1,52 @@
+use dep::lib::{ecrecover, proof};
+
+/// Proves ownership of an ERC20 token balance without revealing the wallet address.
+///
+/// This circuit verifies:
+/// 1. The signer owns a wallet (via ECDSA signature verification)
+/// 2. That wallet has at least `verified_balance` tokens at the given block
+///
+/// Used specifically for $ANON token on Base chain.
+fn main(
+    // Address Data (proves wallet ownership)
+    signature: [u8; 64],
+    message_hash: [u8; 32],
+    pub_key_x: [u8; 32],
+    pub_key_y: [u8; 32],
+    // Storage Proof (proves balance)
+    // Array sizes tuned for ~108k holders (max depth 6, max node 1066 bytes)
+    // Will need to increase if holder count exceeds ~1M
+    storage_hash: [u8; 32],
+    storage_nodes: [[u8; 1080]; 5],
+    storage_leaf: [u8; 120],
+    storage_depth: u32,
+    storage_value: Field,
+    // Verification Data
+    chain_id: Field,
+    block_number: Field,
+    token_address: Field,
+    balance_slot: Field,
+    // Balance Data
+    verified_balance: Field,
+) -> pub (Field, Field, Field, Field, Field, [u8; 32]) {
+    let balance_slot_bytes: [u8; 32] = balance_slot.to_be_bytes();
+    let address: [u8; 32] =
+        ecrecover::ecrecover(pub_key_x, pub_key_y, signature, message_hash).to_be_bytes();
+
+    let key = proof::get_storage_key([address, balance_slot_bytes]);
+    let value = proof::get_storage_value(storage_value);
+
+    proof::verify(
+        key,
+        value,
+        storage_hash,
+        storage_nodes,
+        storage_leaf,
+        storage_depth,
+    );
+
+    // Ensure verified_balance <= actual balance (prevents over-claiming)
+    assert(!storage_value.lt(verified_balance), "Attempt to verify too high balance");
+
+    (verified_balance, chain_id, block_number, token_address, balance_slot, storage_hash)
+}

package/src/index.ts

@@ -0,0 +1,16 @@
+// Set HOME to /tmp for serverless environments (Vercel) where Barretenberg needs write access
+if (typeof process !== 'undefined' && process.env && process.env.VERCEL) {
+  process.env.HOME = '/tmp'
+}
+
+export {
+  AnonBalanceVerifier,
+  getVerifier,
+  ZKCLAW_TOKEN,
+  ANON_TOKEN, // Legacy alias
+  BALANCE_THRESHOLDS,
+  type ProofData,
+  type CredentialData,
+  type BuildInputResult,
+  type GenerateProofInput,
+} from './verifier'

package/src/noir-lib/Nargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "lib"
+type = "lib"
+authors = ["slokh"]
+compiler_version = ">=0.38.0"
+version = "0.1.1"
+
+[dependencies]
+array_helpers = { tag = "v0.30.0", git = "https://github.com/signorecello/noir-array-helpers" }

package/src/noir-lib/src/bytes/mod.nr

@@ -0,0 +1,16 @@
+pub fn bytes_as_nibbles<let N: u32>(bytes: [u8; N]) -> [u8; N * 2] {
+    let mut nibbles = [0; N * 2];
+    for i in 0..N {
+        let nibs = byte_to_nibbles(bytes[i]);
+        nibbles[i * 2] = nibs.0;
+        nibbles[i * 2 + 1] = nibs.1;
+    }
+    nibbles
+}
+
+pub fn byte_to_nibbles(b: u8) -> (u8, u8) {
+    let upper = b >> 4;
+    let lower = b - 16 * upper;
+
+    (upper, lower)
+}

package/src/noir-lib/src/ecrecover/mod.nr

@@ -0,0 +1,40 @@
+mod secp256k1;
+
+pub fn ecrecover(
+    pub_key_x: [u8; 32],
+    pub_key_y: [u8; 32],
+    signature: [u8; 64], // clip v value
+    hashed_message: [u8; 32],
+) -> Field {
+    let key = secp256k1::PubKey::from_xy(pub_key_x, pub_key_y);
+
+    assert(key.verify_sig(signature, hashed_message));
+    let addr = key.to_eth_address();
+
+    addr
+}
+
+#[test]
+fn test_ecrecover() {
+    let pub_key_x = [
+        131, 24, 83, 91, 84, 16, 93, 74, 122, 174, 96, 192, 143, 196, 95, 150, 135, 24, 27, 79, 223,
+        198, 37, 189, 26, 117, 63, 167, 57, 127, 237, 117,
+    ];
+    let pub_key_y = [
+        53, 71, 241, 28, 168, 105, 102, 70, 242, 243, 172, 176, 142, 49, 1, 106, 250, 194, 62, 99,
+        12, 93, 17, 245, 159, 97, 254, 245, 123, 13, 42, 165,
+    ];
+    let signature = [
+        57, 17, 112, 239, 241, 30, 64, 157, 170, 50, 85, 145, 156, 69, 226, 85, 147, 164, 10, 82,
+        71, 93, 42, 132, 200, 220, 161, 255, 95, 241, 211, 141, 81, 7, 150, 25, 25, 27, 162, 213,
+        80, 61, 12, 170, 50, 4, 154, 203, 252, 229, 119, 29, 202, 153, 50, 25, 126, 145, 245, 23,
+        136, 75, 29, 177,
+    ];
+    let hashed_message = [
+        13, 82, 120, 60, 76, 186, 215, 235, 175, 126, 185, 67, 252, 100, 143, 82, 130, 165, 32, 112,
+        68, 47, 193, 141, 141, 209, 109, 219, 47, 203, 175, 102,
+    ];
+
+    let addr = ecrecover(pub_key_x, pub_key_y, signature, hashed_message);
+    assert(addr == 0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266);
+}

package/src/noir-lib/src/ecrecover/secp256k1.nr

@@ -0,0 +1,87 @@
+use dep::std;
+
+use dep::array_helpers;
+
+struct PubKey {
+    pub_x: [u8; 32],
+    pub_y: [u8; 32],
+}
+
+fn split_uncompressed_pub_key(pub_key: [u8; 65]) -> ([u8; 32], [u8; 32]) {
+    let mut pub_key_x: [u8; 32] = [0; 32];
+    let mut pub_key_y: [u8; 32] = [0; 32];
+
+    for i in 0..32 {
+        pub_key_x[i] = pub_key[i + 1];
+        pub_key_y[i] = pub_key[i + 32 + 1];
+    }
+
+    (pub_key_x, pub_key_y)
+}
+
+impl PubKey {
+    fn from_xy(pub_x: [u8; 32], pub_y: [u8; 32]) -> PubKey {
+        PubKey { pub_x, pub_y }
+    }
+
+    fn from_unified(pub_key: [u8; 64]) -> PubKey {
+        let (key_x, key_y) = array_helpers::split_u8_64(pub_key);
+
+        PubKey { pub_x: key_x, pub_y: key_y }
+    }
+
+    fn from_uncompressed(pub_key: [u8; 65]) -> PubKey {
+        assert(pub_key[0] == 0x04);
+        let (key_x, key_y) = split_uncompressed_pub_key(pub_key);
+
+        PubKey { pub_x: key_x, pub_y: key_y }
+    }
+
+    fn verify_sig(self, signature: [u8; 64], hashed_message: [u8; 32]) -> bool {
+        std::ecdsa_secp256k1::verify_signature(self.pub_x, self.pub_y, signature, hashed_message)
+    }
+
+    fn to_eth_address(self) -> Field {
+        let pub_key = array_helpers::u8_32_to_u8_64(self.pub_x, self.pub_y);
+        let hashed_pub_key = std::hash::keccak256(pub_key, 64);
+
+        let mut addr: Field = 0;
+        for i in 0..20 {
+            // shift left by 8 and add the new value
+            addr = (addr * 256) + hashed_pub_key[i + 12] as Field;
+        }
+
+        addr
+    }
+
+    fn ecrecover(self, signature: [u8; 64], hashed_message: [u8; 32]) -> Field {
+        assert(self.verify_sig(signature, hashed_message));
+
+        self.to_eth_address()
+    }
+}
+
+#[test]
+fn test_ecrecover_via_key() {
+    let pub_key_x = [
+        131, 24, 83, 91, 84, 16, 93, 74, 122, 174, 96, 192, 143, 196, 95, 150, 135, 24, 27, 79, 223,
+        198, 37, 189, 26, 117, 63, 167, 57, 127, 237, 117,
+    ];
+    let pub_key_y = [
+        53, 71, 241, 28, 168, 105, 102, 70, 242, 243, 172, 176, 142, 49, 1, 106, 250, 194, 62, 99,
+        12, 93, 17, 245, 159, 97, 254, 245, 123, 13, 42, 165,
+    ];
+    let signature = [
+        57, 17, 112, 239, 241, 30, 64, 157, 170, 50, 85, 145, 156, 69, 226, 85, 147, 164, 10, 82,
+        71, 93, 42, 132, 200, 220, 161, 255, 95, 241, 211, 141, 81, 7, 150, 25, 25, 27, 162, 213,
+        80, 61, 12, 170, 50, 4, 154, 203, 252, 229, 119, 29, 202, 153, 50, 25, 126, 145, 245, 23,
+        136, 75, 29, 177,
+    ];
+    let hashed_message = [
+        13, 82, 120, 60, 76, 186, 215, 235, 175, 126, 185, 67, 252, 100, 143, 82, 130, 165, 32, 112,
+        68, 47, 193, 141, 141, 209, 109, 219, 47, 203, 175, 102,
+    ];
+
+    let key = PubKey::from_xy(pub_key_x, pub_key_y);
+    assert(key.ecrecover(signature, hashed_message) == 0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266);
+}

package/src/noir-lib/src/lib.nr

@@ -0,0 +1,4 @@
+pub mod bytes;
+pub mod ecrecover;
+pub mod rlp;
+pub mod proof;