🎫 Emit HumanIDv1 add events for offchain MerkleTree listeners

- Refactor humandID from a function library to a base `SmartContract`
- Emit "KimlikDAO-add-HumanIDv1" event each time a HumanIDv1 is accepted
- Emit "KimlikDAO-init" add app contract initialization along with the
  MerkleTree height.

Author: KimlikDAO-bot

lib

@@ -1,5 +1,5 @@
 import { Field, Poseidon, PrivateKey, PublicKey, Signature } from "o1js";
-import { Signatures, authenticate, requireConsistent } from "./humanIDv1";
+import { HumanIDv1, authenticate, requireConsistent } from "./HumanIDv1";
 
 const Nodes = [
   PrivateKey.fromBigInt(1n),
@@ -15,44 +15,40 @@ const blindingCommit = (sender: PublicKey) => {
   ];
 };
 
-const signHumanIDv1 = (
-  humanIDv1Key: bigint,
-  sender: PublicKey
-): [Field, Field, Signatures] => {
-  const humanIDv1 = Field(humanIDv1Key);
+const signHumanIDv1 = (humanIDv1Id: bigint, sender: PublicKey): HumanIDv1 => {
+  const id = Field(humanIDv1Id);
   const [commitmentR, commitment] = blindingCommit(sender);
-  const sigs = new Signatures({
-    sig0: Signature.create(Nodes[0], [humanIDv1, commitment]),
-    sig1: Signature.create(Nodes[1], [humanIDv1, commitment]),
-    sig2: Signature.create(Nodes[2], [humanIDv1, commitment]),
+  return new HumanIDv1({
+    id,
+    commitmentR,
+    sig0: Signature.create(Nodes[0], [id, commitment]),
+    sig1: Signature.create(Nodes[1], [id, commitment]),
+    sig2: Signature.create(Nodes[2], [id, commitment]),
   });
-  return [humanIDv1, commitmentR, sigs];
 };
 
-const truncateHumanIDv1 = (humanIDv1Key: bigint) => humanIDv1Key & 0xffffffffn;
-
-const badSignHumanIDv1 = (
-  humanIDv1Key: bigint,
-  sender: PublicKey
-): [Field, Field, Signatures] => {
-  const humanIDv1 = Field(humanIDv1Key);
+const badSignHumanIDv1 = (humanIDv1: bigint, sender: PublicKey): HumanIDv1 => {
+  const id = Field(humanIDv1);
   const [commitmentR, commitment] = blindingCommit(sender);
-  const sigs = new Signatures({
-    sig0: Signature.create(Nodes[0], [humanIDv1, commitment]),
-    sig1: Signature.create(Nodes[1], [humanIDv1, commitment]),
-    sig2: Signature.create(Nodes[3], [humanIDv1, commitment]),
+  return new HumanIDv1({
+    id,
+    commitmentR,
+    sig0: Signature.create(Nodes[0], [id, commitment]),
+    sig1: Signature.create(Nodes[1], [id, commitment]),
+    sig2: Signature.create(Nodes[0], [id, commitment]),
   });
-  return [humanIDv1, commitmentR, sigs];
 };
 
+const truncateHumanIDv1 = (id: bigint) => id & 0xffffffffn;
+
 describe("humanIDv1 SDK tests", () => {
   it("should authenticate geniune humanIDv1s and reject others", () => {
     const claimant = PrivateKey.fromBigInt(0x1337n).toPublicKey();
     expect(() =>
-      authenticate(claimant, ...signHumanIDv1(100n, claimant))
+      authenticate(claimant, signHumanIDv1(100n, claimant))
     ).not.toThrow();
     expect(() =>
-      authenticate(claimant, ...badSignHumanIDv1(200n, claimant))
+      authenticate(claimant, badSignHumanIDv1(200n, claimant))
     ).toThrow();
   });
 

mina/humanIDv1.test.ts mina/HumanIDv1.test.ts

@@ -0,0 +1,98 @@
+import {
+  Field,
+  MerkleWitness,
+  Poseidon,
+  PrivateKey,
+  PublicKey,
+  Signature,
+  SmartContract,
+  State,
+  Struct,
+  state,
+} from "o1js";
+
+class HumanIDv1 extends Struct({
+  id: Field,
+  commitmentR: Field,
+  sig0: Signature,
+  sig1: Signature,
+  sig2: Signature,
+}) { }
+
+class HumanIDv1Witness extends MerkleWitness(33) { }
+
+const KimlikDAONodes = [
+  PrivateKey.fromBigInt(1n).toPublicKey(),
+  PrivateKey.fromBigInt(2n).toPublicKey(),
+  PrivateKey.fromBigInt(3n).toPublicKey(),
+];
+
+const authenticate = (owner: PublicKey, hid: HumanIDv1) => {
+  const commitment = Poseidon.hash([
+    hid.commitmentR,
+    owner.x.add(owner.isOdd.toField()),
+  ]);
+  hid.sig0.verify(KimlikDAONodes[0], [hid.id, commitment]).assertTrue();
+  hid.sig1.verify(KimlikDAONodes[1], [hid.id, commitment]).assertTrue();
+  hid.sig2.verify(KimlikDAONodes[2], [hid.id, commitment]).assertTrue();
+};
+
+const EmptyRoot =
+  Field(0x21afce36daa1a2d67391072035f4555a85aea7197e5830b128f121aa382770cdn);
+
+const Inverse2Exp32 =
+  Field(0x3fffffffc00000000000000000000000224698fbe706601f8fe037d166d2cf14n);
+
+const requireConsistent = (humanIDv1: Field, truncatedHumanIDv1: Field) =>
+  humanIDv1
+    .sub(truncatedHumanIDv1)
+    .mul(Inverse2Exp32)
+    .assertLessThan(
+      (1n << 222n) + 0x224698fc094cf91b992d30edn,
+      "HumanID does not match the witness"
+    );
+
+class PerHumanIDv1 extends SmartContract {
+  events = {
+    "KimlikDAO-init": Field, // Emits the tree height along with init event
+    "KimlikDAO-add-HumanIDv1": Field, // Emits the added HumanIDv1.id
+  };
+
+  @state(Field) treeRoot = State<Field>();
+
+  init() {
+    super.init();
+    this.treeRoot.set(EmptyRoot);
+    this.emitEvent("KimlikDAO-init", Field(32));
+  }
+
+  acceptHumanIDv1(
+    owner: PublicKey,
+    humanIDv1: HumanIDv1,
+    witness: HumanIDv1Witness
+  ) {
+    authenticate(owner, humanIDv1);
+    requireConsistent(humanIDv1.id, witness.calculateIndex());
+    this.addToMerkleTree(witness);
+    this.emitEvent("KimlikDAO-add-HumanIDv1", humanIDv1.id);
+  }
+
+  addToMerkleTree(witness: HumanIDv1Witness) {
+    const currentTreeRoot = this.treeRoot.getAndRequireEquals();
+    currentTreeRoot.assertEquals(
+      witness.calculateRoot(Field(0)),
+      "HumanID already exists in the set"
+    );
+    this.treeRoot.set(witness.calculateRoot(Field(1)));
+  }
+}
+
+export {
+  EmptyRoot,
+  HumanIDv1,
+  HumanIDv1Witness,
+  KimlikDAONodes,
+  PerHumanIDv1,
+  authenticate,
+  requireConsistent
+};

mina/HumanIDv1.ts

@@ -1,6 +1,6 @@
 import { Field, MerkleTree, Mina, PrivateKey, PublicKey, UInt64 } from "o1js";
-import { HumanIDWitness } from "../humanIDv1";
-import { signHumanIDv1, truncateHumanIDv1 } from "../humanIDv1.test";
+import { HumanIDv1Witness } from "../HumanIDv1";
+import { signHumanIDv1, truncateHumanIDv1 } from "../HumanIDv1.test";
 import { Airdrop } from "./Airdrop";
 
 describe("Example Airdrop zkApp", () => {
@@ -32,7 +32,7 @@ describe("Example Airdrop zkApp", () => {
 
   const getWitnessAndInsert = (humanIDv1Key: bigint) => {
     const truncated = truncateHumanIDv1(humanIDv1Key);
-    const witness = new HumanIDWitness(tree.getWitness(truncated));
+    const witness = new HumanIDv1Witness(tree.getWitness(truncated));
     tree.setLeaf(truncated, Field(1));
     return witness;
   };
@@ -42,7 +42,7 @@ describe("Example Airdrop zkApp", () => {
 
   it("should let people claimReward()", () =>
     Mina.transaction(sender, () =>
-      app.claimReward(...signHumanIDv1(100n, sender), getWitnessAndInsert(100n))
+      app.claimReward(signHumanIDv1(100n, sender), getWitnessAndInsert(100n))
     )
       .prove()
       .sign([senderKey])
@@ -51,15 +51,15 @@ describe("Example Airdrop zkApp", () => {
   it("should let 2 people claimReward()", async () => {
     const id1 = 123123123123123123123123123123n;
     await Mina.transaction(sender, () =>
-      app.claimReward(...signHumanIDv1(id1, sender), getWitnessAndInsert(id1))
+      app.claimReward(signHumanIDv1(id1, sender), getWitnessAndInsert(id1))
     )
       .prove()
       .sign([senderKey])
       .send();
 
     const id2 = 123123123123123123123123123124n;
     await Mina.transaction(sender, () =>
-      app.claimReward(...signHumanIDv1(id2, sender), getWitnessAndInsert(id2))
+      app.claimReward(signHumanIDv1(id2, sender), getWitnessAndInsert(id2))
     )
       .prove()
       .sign([senderKey])
@@ -70,7 +70,7 @@ describe("Example Airdrop zkApp", () => {
     const id = 123123123123123123123123123124n;
     expect(() =>
       Mina.transaction(sender, () =>
-        app.claimReward(...signHumanIDv1(id, sender), getWitnessAndInsert(100n))
+        app.claimReward(signHumanIDv1(id, sender), getWitnessAndInsert(100n))
       )
         .prove()
         .sign([senderKey])
@@ -81,15 +81,15 @@ describe("Example Airdrop zkApp", () => {
   it("should not let double claimReward()", async () => {
     const id = 123123123123123123123123123123n;
     await Mina.transaction(sender, () =>
-      app.claimReward(...signHumanIDv1(id, sender), getWitnessAndInsert(id))
+      app.claimReward(signHumanIDv1(id, sender), getWitnessAndInsert(id))
     )
       .prove()
       .sign([senderKey])
       .send();
 
     expect(() =>
       Mina.transaction(sender, () =>
-        app.claimReward(...signHumanIDv1(id, sender), getWitnessAndInsert(id))
+        app.claimReward(signHumanIDv1(id, sender), getWitnessAndInsert(id))
       )
         .prove()
         .sign([senderKey])
@@ -101,7 +101,7 @@ describe("Example Airdrop zkApp", () => {
     let firstBalance = Mina.getBalance(sender);
 
     await Mina.transaction(sender, () =>
-      app.claimReward(...signHumanIDv1(100n, sender), getWitnessAndInsert(100n))
+      app.claimReward(signHumanIDv1(100n, sender), getWitnessAndInsert(100n))
     )
       .prove()
       .sign([senderKey])

mina/examples/Airdrop.test.ts

@@ -1,38 +1,15 @@
-import {
-  Field,
-  SmartContract,
-  State,
-  method,
-  state,
-} from "o1js";
-import {
-  EmptyRoot,
-  HumanIDWitness,
-  Signatures,
-  acceptHumanIDv1,
-} from "../humanIDv1";
+import { method } from "o1js";
+import { HumanIDv1, HumanIDv1Witness, PerHumanIDv1 } from "../HumanIDv1";
 
 const MINA = 1e9;
 
 /**
  * Example airdrop zkApp, which gives 10 MINA rewards to each unique human.
  */
-class Airdrop extends SmartContract {
-  @state(Field) treeRoot = State<Field>();
-
-  init() {
-    super.init();
-    this.treeRoot.set(EmptyRoot);
-  }
-
-  @method async claimReward(
-    humanIDv1: Field,
-    commitmentR: Field,
-    sigs: Signatures,
-    witness: HumanIDWitness,
-  ) {
+class Airdrop extends PerHumanIDv1 {
+  @method async claimReward(humanIDv1: HumanIDv1, witness: HumanIDv1Witness) {
     const sender = this.sender.getUnconstrained();
-    acceptHumanIDv1(sender, humanIDv1, commitmentR, sigs, this.treeRoot, witness);
+    this.acceptHumanIDv1(sender, humanIDv1, witness);
     this.send({ to: sender, amount: 10 * MINA });
   }
 }