feat: javascript point compression

Author: jmagan

.gitignore

@@ -4,3 +4,7 @@ artifacts/
 build/
 # Aiken's default documentation export
 docs/
+
+
+node_modules
+conversion/package-lock.json

conversion/index.js

@@ -1,51 +1,161 @@
 const fs = require("fs");
+const bb = require("bigint-buffer");
+const ff = require("ffjavascript");
 
 const proof = JSON.parse(fs.readFileSync("proof.json", "utf-8"));
 const verificationKey = JSON.parse(fs.readFileSync("verification_key.json", "utf-8"));
 
-console.log("Proof", JSON.stringify(proof));
+async function compressedG1(point) {
+  const curve = await ff.getCurveFromName("bls12381");
 
-function uncompressedFq(number) {
-  const buffer = Buffer.alloc(48);
-  buffer.write(BigInt(number).toString(16), 0, 48, "hex");
-  return buffer.toString("hex");
-}
+  const result = bb.toBufferBE(BigInt(point[0]), 48);
+  const COMPRESSED = 0b10000000;
+  const INFINITY = 0b01000000;
+  const YBIT = 0b00100000;
+
+  result[0] = result[0] | COMPRESSED;
+
+  if (BigInt(point[2]) !== 1n) {
+    result[0] = result[0] | INFINITY;
+  } else {
+    const F = curve.G1.F;
+
+    const x = F.fromObject(BigInt(point[0]));
+
+    const x3b = F.add(F.mul(F.square(x), x), curve.G1.b);
+    const y1 = F.toObject(F.sqrt(x3b));
+    const y2 = F.toObject(F.neg(F.sqrt(x3b)));
+
+    const y = BigInt(point[1]);
 
-function uncompressedG1(point) {
-  const x = uncompressedFq(point[0]);
-  return x;
+    if (y1 > y2 && y > y2) {
+      result[0] = result[0] | YBIT;
+    } else if (y1 < y2 && y > y1) {
+      result[0] = result[0] | YBIT;
+    }
+  }
+
+
+  return result.toString("hex");
 }
 
-function uncompressedG2(point) {
-  const x = uncompressedFq(point[0][0]) + uncompressedFq(point[0][1]);
-  return x;
+async function compressedG2(point) {
+  const curve = await ff.getCurveFromName("bls12381");
+
+  const result = Buffer.concat([bb.toBufferBE(BigInt(point[0][1]), 48), bb.toBufferBE(BigInt(point[0][0]), 48)]);
+  const COMPRESSED = 0b10000000;
+  const INFINITY = 0b01000000;
+  const YBIT = 0b00100000;
+
+  result[0] = result[0] | COMPRESSED;
+
+  if (BigInt(point[2][0]) !== 1n) {
+    result[0] = result[0] | INFINITY;
+  } else {
+    const F = curve.G2.F;
+
+    const x = F.fromObject(point[0].map(item => BigInt(item)));
+
+    // console.log("x", x);
+
+    const x3b = F.add(F.mul(F.square(x), x), curve.G2.b);
+    const y1 = F.toObject(F.sqrt(x3b));
+    const y2 = F.toObject(F.neg(F.sqrt(x3b)));
+    // console.log("y1", y1);
+    // console.log("y2", y2);
+    // console.log("point", point[1]);
+
+    function greaterThan(a, b) {
+      if (a[1] > b[1]) {
+        return true
+      } else if (a[1] === b[1] && a[0] > b[0]) {
+        return true;
+      }
+      return false;
+    }
+
+    const y = point[1].map(item => BigInt(item));
+
+    if (greaterThan(y1, y2) && greaterThan(y, y2)) {
+      result[0] = result[0] | YBIT;
+    } else if (greaterThan(y2, y1) && greaterThan(y, y1)) {
+      result[0] = result[0] | YBIT;
+    }
+  }
+  return result.toString("hex");
 }
 
-function convertProofToUncompressed(proof) {
+
+async function convertProofToUncompressed(proof) {
 
   const uncompressedProof = {
-    "pi_a": uncompressedG1(proof.pi_a),
-    "pi_b": uncompressedG2(proof.pi_b),
-    "pi_c": uncompressedG1(proof.pi_c),
+    "pi_a": await compressedG1(proof.pi_a),
+    "pi_b": await compressedG2(proof.pi_b),
+    "pi_c": await compressedG1(proof.pi_c),
   }
 
   return uncompressedProof;
 }
 
 
-function convertVerificationKeyToUncompressed(verificationKey) {
+async function convertVerificationKeyToUncompressed(verificationKey) {
   const uncompressedVerificationKey = {
-    "vk_alpha_1": uncompressedG1(verificationKey.vk_alpha_1),
-    "vk_beta_2": uncompressedG2(verificationKey.vk_beta_2),
-    "vk_gamma_2": uncompressedG2(verificationKey.vk_gamma_2),
-    "vk_delta_2": uncompressedG2(verificationKey.vk_delta_2),
-    "IC": verificationKey.IC.map((item) => uncompressedG1(item)),
+    "vk_alpha_1": await compressedG1(verificationKey.vk_alpha_1),
+    "vk_beta_2": await compressedG2(verificationKey.vk_beta_2),
+    "vk_gamma_2": await compressedG2(verificationKey.vk_gamma_2),
+    "vk_delta_2": await compressedG2(verificationKey.vk_delta_2),
+    "IC": verificationKey.IC.map(async (item) => await compressedG1(item)),
   }
 
   return uncompressedVerificationKey;
 }
 
-console.log("Uncompressed proof", JSON.stringify(convertProofToUncompressed(proof)));
+async function printCompressedProof() {
+  console.log("Compressed proof", JSON.stringify(await convertProofToUncompressed(proof)));
+}
+
+printCompressedProof();
 
-console.log("\n\nUncompressed verification key", JSON.stringify(convertVerificationKeyToUncompressed(verificationKey)));
+async function printCompressedVerificationKey() {
+  console.log("\n\nUncompressed verification key", JSON.stringify(await convertVerificationKeyToUncompressed(verificationKey)));
+}
+
+printCompressedVerificationKey();
+
+
+async function ffTest() {
+  const curve = await ff.getCurveFromName("bls12381");
+
+  const point = proof.pi_c;
+
+  const xBufferBE = bb.toBufferBE(BigInt(point[0]), 48);
+
+  console.log("Point x buffer BE", new Uint8Array(xBufferBE));
+
+  const xBufferLE = bb.toBufferLE(BigInt(point[0]), 48);
+
+  console.log("Point x buffer LE", new Uint8Array(xBufferLE));
+
+
+  const g1Element = curve.G1.fromObject(point.map((item) => BigInt(item).toString(16)));
+
+  console.log("G1 element", g1Element);
+
+  console.log("G1 Element is valid", curve.G1.isValid(g1Element));
+
+  const buff = new Uint8Array(48);
+
+  curve.G1.toRprCompressed(buff, 0, g1Element);
+
+  console.log("G1 element Compressed", buff);
+
+  console.log("MSB", buff[0].toString(2));
+
+  const g1ElementFromCompressed = curve.G1.fromRprCompressed(buff, 0);
+
+  console.log("G1 from compressed", g1ElementFromCompressed);
+
+  console.log("G1 from compressed is valid", curve.G1.isValid(g1ElementFromCompressed));
+}
 
+// ffTest();

conversion/package.json

@@ -9,5 +9,9 @@
   },
   "keywords": [],
   "author": "",
-  "license": "ISC"
+  "license": "ISC",
+  "dependencies": {
+    "bigint-buffer": "^1.1.5",
+    "ffjavascript": "^0.2.63"
+  }
 }

lib/ak-381/groth16.ak

@@ -85,6 +85,9 @@ pub fn groth_verify(
 // }
 
 test bls_point_construction() {
-  let point_1 = #<Bls12_381, G1>"184bb665c37ff561a89ec2122dd343f20e0f4cbcaec84e3c3052ea81d1834e192c426074b02ed3dca4e7676ce4ce48ba"
+  let point_g1 = #<Bls12_381, G1>"b28cb29bc282be68df977b35eb9d8e98b3a0a3fc7c372990bddc50419ca86693e491755338fed4fb42231a7c081252ce"
+
+  let point_g2 = #<Bls12_381, G2>"8cd68a7186a908212680a0234d8210c20328f8fb3ce1d69c9aec9330a5802d6cfaf6d7cf3176133221c19188590cb4141874ea7bbfcb9872931e115d882c46b90c3dcbcee10062d1c9b9b0a691d7bec7d2735f06495c7f71dea210e55b2782df"
+
   True
 }