Merge pull request #9 from Portkey-Wallet/refactor/remove-old-circuits

Refactor: remove old circuits

.github/workflows/build.yml

@@ -12,7 +12,7 @@ jobs:
 
     strategy:
       matrix:
-        circuit_name: [zkLogin, zkLoginPoseidon, hashMapping]  # Add your circuit names here
+        circuit_name: [zkLogin, zkLoginSha256, idHashMapping]  # Add your circuit names here
 
     container:
       image: debian:bookworm

.github/workflows/test.yml

@@ -32,10 +32,4 @@ jobs:
         run: npm install
 
       - name: Test the main circuit
-        run: npm run test tests/zkLogin.test.ts
-
-      - name: Test circuit using Poseidon
-        run: npm run test tests/zkLoginPoseidon.test.ts
-
-      - name: Test hash mapping circuit
-        run: npm run test tests/hash-mapping.test.ts
+        run: npm run test

.gitignore

@@ -2,8 +2,9 @@ node_modules
 out
 *.ptau
 *.zkey
-tests/compiled-test-circuit
+tests/**/compiled-test-circuit
 *.r1cs
 *.wtns
 bls12381/
-bn128/
+bn128/
+.DS_Store

circuits/helpers/guardian-identifier-hash-poseidon.circom → circuits/helpers/idhash_poseidon.circom

@@ -1,7 +1,7 @@
 pragma circom 2.0.0;
 include "./hashtofield.circom";
 
-template IdentifierHashByPoseidon(sub_bytes, salt_bytes){
+template IdHashPoseidon(sub_bytes, salt_bytes){
   signal input sub[sub_bytes];
   signal input salt[salt_bytes];
 

circuits/helpers/idhash_sha256.circom

@@ -0,0 +1,31 @@
+pragma circom 2.0.0;
+include "./sha256.circom";
+include "./utils.circom";
+
+template IdHashSha256(sub_bytes, salt_bytes){
+  // inputs
+  signal input sub[sub_bytes];
+  signal input sub_len;
+  signal input salt[salt_bytes];
+  signal input salt_len;
+  signal output out[32];
+
+  // Step 1: Hash the sub value
+  component subHasher = Sha256PadAndHash(sub_bytes);
+  subHasher.in <== sub;
+  subHasher.in_len <== sub_len;
+
+  // Step 2: Combine the hash with the salt
+  var hash2_bytes = salt_bytes + 32;
+
+  component concatenated = CombineBytes(32, salt_bytes);
+  concatenated.first <== subHasher.out;
+  concatenated.second <== salt;
+
+  // Step 3: Hash the concatenated value
+  component idHasher = Sha256PadAndHash(hash2_bytes);
+
+  idHasher.in <== concatenated.out;
+  idHasher.in_len <== hash2_bytes;
+  out <== idHasher.out;
+}

circuits/helpers/sha256.circom

@@ -9,6 +9,33 @@ include "./string.circom";
 include "./sha256general.circom";
 include "./sha256partial.circom";
 
+template Sha256PadAndHash(max_bytes){
+  signal input in[max_bytes];
+  signal input in_len;
+  signal output out[32];
+
+  var max_padded_len = (max_bytes + 9) + (64 - (max_bytes + 9) % 64);
+
+  var paddedBytes[max_padded_len];
+  for (var i = 0; i < in_len; i++) {
+      paddedBytes[i] = in[i];
+  }
+
+  for (var i = in_len; i < max_padded_len; i++) {
+      paddedBytes[i] = 0;
+  }
+
+  component sha256Pad = Sha256PadBytes(max_padded_len);
+  sha256Pad.in <-- paddedBytes;
+  sha256Pad.in_bytes <== in_len;
+
+  component sha256BB = Sha256BytesOutputBytes(max_padded_len);
+
+  sha256BB.in_padded <== sha256Pad.padded_text;
+  sha256BB.in_len_padded_bytes <== sha256Pad.padded_len;
+  out <== sha256BB.out;
+}
+
 template Sha256BytesOutputBytes(max_num_bytes) {
     signal input in_padded[max_num_bytes];
     signal input in_len_padded_bytes;
@@ -53,14 +80,16 @@ template Sha256PadBytes(max_bytes) {
     // in_bytes + 1 bytes + 8 bytes length < max_bytes
     assert(in_bytes + 9 < max_bytes);
 
-    padded_len <-- (in_bytes + 9) + (64 - (in_bytes + 9) % 64);
+    var padding_len = (in_bytes + 9) == 64 ? 0 : 64 - (in_bytes + 9) % 64;
+
+    padded_len <-- (in_bytes + 9) + padding_len;
     assert(padded_len % 64 == 0);
 
     component len2bytes = Packed2BytesBigEndian(8);
     len2bytes.in <== in_bytes * 8;
 
     for (var i = 0; i < max_bytes; i++) {
-        padded_text[i] <-- i < in_bytes ? in[i] : (i == in_bytes ? (1 << 7) : (i < padded_len ? (i % 64 < 56 ? 0 : (i % 64 > 56 ? len2bytes.out[(i % 64 - 56)]: 0)) : 0)); // Add the 1 on the end and text length
+        padded_text[i] <-- i < in_bytes ? in[i] : (i == in_bytes ? (1 << 7) : ((i < padded_len && i >= padded_len - 8) ? len2bytes.out[(i % 64 - 56)]: 0)); // Add the 1 on the end and text length
     }
 }
 
@@ -75,15 +104,16 @@ template Sha256Pad(max_bytes) {
 
     // len.length + 1 bytes + 8 bytes length < max_bytes
     assert(len.length + 9 < max_bytes);
+    var padding_len = (len.length + 9) == 64 ? 0 : 64 - (len.length + 9) % 64;
 
-    padded_len <-- (len.length + 9) + (64 - (len.length + 9) % 64);
+    padded_len <-- (len.length + 9) + padding_len;
     assert(padded_len % 64 == 0);
 
     component len2bytes = Packed2BytesBigEndian(8);
     len2bytes.in <== len.length * 8;
 
     for (var i = 0; i < max_bytes; i++) {
-        padded_text[i] <-- i < len.length ? text[i] : (i == len.length ? (1 << 7) : (i < padded_len ? (i % 64 < 56 ? 0 : (i % 64 > 56 ? len2bytes.out[(i % 64 - 56)]: 0)) : 0)); // Add the 1 on the end and text length
+        padded_text[i] <-- i < len.length ? text[i] : (i == len.length ? (1 << 7) : ((i < padded_len && i >= padded_len - 8) ? len2bytes.out[(i % 64 - 56)]: 0)); // Add the 1 on the end and text length
     }
 }
 

circuits/hashMapping.circom → circuits/idHashMapping.circom

@@ -1,21 +1,19 @@
 pragma circom 2.0.0;
-include "./helpers/guardian-identifier-hash.circom";
-include "./helpers/guardian-identifier-hash-poseidon.circom";
-include "./helpers/base64.circom";
-include "./helpers/jwt-sub-extract.circom";
+include "./helpers/idhash_sha256.circom";
+include "./helpers/idhash_poseidon.circom";
 include "./helpers/jwtchecks.circom";
 
-template Sha256ToPoseidonMapping(maxSubLen, maxSaltLen){
+template IdHashMapping(maxSubLen, maxSaltLen){
     signal input sub[maxSubLen];
     signal input subLen;
     signal input salt[maxSaltLen];
     signal input saltLen;
-    component poseidonHasher = IdentifierHashByPoseidon(maxSubLen, maxSaltLen);
+    component poseidonHasher = IdHashPoseidon(maxSubLen, maxSaltLen);
 
     poseidonHasher.sub <== sub;
     poseidonHasher.salt <== salt;
 
-    component sha256Hasher = GuardianIdentifierHash(maxSubLen, 16);
+    component sha256Hasher = IdHashSha256(maxSubLen, 16);
 
     sha256Hasher.sub <== sub;
     sha256Hasher.sub_len <== subLen;
@@ -26,4 +24,4 @@ template Sha256ToPoseidonMapping(maxSubLen, maxSaltLen){
     signal output sha256_hash[32] <== sha256Hasher.out;
 }
 
-component main = Sha256ToPoseidonMapping(255, 16);
+component main = IdHashMapping(255, 16);