exercise-4a-calc.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0f7e8976-2003-41c4-a2ae-aa3ccc3451b0",
   "metadata": {},
   "source": [
    "# Exercise 4a - ZKP Considerations - measurements\n",
    "\n",
    "The main difference we saw, so far, is that LegoGroth16 requires the verifier to create a key pair, and send one key to the credential holder, while using the other one later to verify the range proof.\n",
    "\n",
    "**Now, we will compare the two algorithms on two aspects:**\n",
    "1. Time to create the proof\n",
    "2. Size of messages exchanged\n",
    "\n",
    "**Note:**\n",
    "We will use **BP** for bulletProof++ and **LG** for LegoGroth16\n",
    "\n",
    "## Sections\n",
    "\n",
    "1. Setup\n",
    "2. LegoGroth16\n",
    "3. Bulletproofs++\n",
    "4. Printing values for plots"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "beb5402d-bf45-488c-a236-7f17431852d1",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## 1. Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7fe47f62-9b21-474a-982a-9dc17efbec52",
   "metadata": {},
   "outputs": [],
   "source": [
    "// Common setup - creating a credential, an issuer, and a signature.\n",
    "\n",
    "import { initializeWasm, BBSKeypair, BBSSignatureParams, BBS_SIGNATURE_PARAMS_LABEL_BYTES,\n",
    "       CredentialSchema, BBSCredentialBuilder, BBSCredential, SUBJECT_STR } from '@docknetwork/crypto-wasm-ts'\n",
    "await initializeWasm();\n",
    "\n",
    "// Credential used for measurements\n",
    "const E_ID_SCHEMA = {\n",
    "    type: 'object',\n",
    "    properties: {\n",
    "        name: { type: 'string' },\n",
    "        profession: { type: 'string' },\n",
    "        timeOfBirth: { type: 'integer', minimum: 0, maximum: 120},\n",
    "        height: {type: 'integer', minimum: 130, maximum: 210},\n",
    "        weight: {type: 'number', minimum: 40, multipleOf: 0.1}\n",
    "    }\n",
    "}\n",
    "const E_ID_DATA = {\n",
    "    name: \"Jack Sparrow\",\n",
    "    timeOfBirth: new Date(\"1993-08-01T00:00:00\").getTime(),\n",
    "    profession: \"IT Manager\",\n",
    "    height: 176,\n",
    "    weight: 84\n",
    "}\n",
    "\n",
    "// Setting up the issuer and creating the signatures\n",
    "\n",
    "const stringToBytes = (str: string) => Uint8Array.from(Buffer.from(str, \"utf-8\"));\n",
    "\n",
    "const params = BBSSignatureParams.generate(100, BBS_SIGNATURE_PARAMS_LABEL_BYTES);\n",
    "const keypair = BBSKeypair.generate(params, stringToBytes('seed1'));\n",
    "\n",
    "const secretKey = keypair.secretKey;\n",
    "const publicKey = keypair.publicKey;\n",
    "\n",
    "const schema = CredentialSchema.essential(); \n",
    "schema.properties[SUBJECT_STR] = E_ID_SCHEMA\n",
    "\n",
    "const builder = new BBSCredentialBuilder();\n",
    "builder.schema = new CredentialSchema(schema);\n",
    "builder.subject = E_ID_DATA\n",
    "\n",
    "const credential = builder.sign(secretKey);\n",
    "\n",
    "const credentialToSendToHolder = credential.toJSON();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f951019f-c514-4297-a346-af097f106897",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## 2. LegoGroth16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ab68e7b-2e01-46df-a325-0a7648134356",
   "metadata": {},
   "outputs": [],
   "source": [
    "// LegoGroth16\n",
    "import { BoundCheckSnarkSetup, SetupParam } from '@docknetwork/crypto-wasm-ts';\n",
    "\n",
    "// We measure the time taken to create the verification keys\n",
    "let LGProofTimes: number[] = []\n",
    "let LGProofSizes: number[] = []\n",
    "let LGVerificationTimes: number[] = []\n",
    "\n",
    "// Setup time\n",
    "let startTime = performance.now();\n",
    "const provingKey = BoundCheckSnarkSetup();\n",
    "const snarkProvingKey = provingKey.decompress();\n",
    "const snarkVerifyingKey = provingKey.getVerifyingKeyUncompressed();\n",
    "\n",
    "let LGSetupTime = Math.floor(performance.now() - startTime) / 1000;\n",
    "LGProofTimes.push(LGSetupTime);\n",
    "console.log(`Time taken to setup LG16: ${LGSetupTime} seconds`);\n",
    "\n",
    "// Proof creation without any range bounds\n",
    "startTime = performance.now()\n",
    "let builder = new PresentationBuilder();\n",
    "builder.addCredential(credential, publicKey)\n",
    "builder.markAttributesRevealed(0, new Set<string>(['credentialSubject.name', 'credentialSubject.profession']));\n",
    "let presentation = builder.finalize();\n",
    "consumedTime = Math.floor(performance.now() - startTime) / 1000;\n",
    "presentation.verify([publicKey], undefined, undefined);\n",
    "verificationTime = (Math.floor(performance.now() - startTime - (consumedTime * 1000)) / 1000);\n",
    "LGProofTimes.push(consumedTime);\n",
    "LGVerificationTimes.push(verificationTime);\n",
    "LGProofSizes.push(presentation.proof.bytes.length);                \n",
    "console.log(`Proof size without any range bounds is: ${presentation.proof.bytes.length} bytes`);\n",
    "console.log(`Time taken to generate proof with no range bounds ~${consumedTime} seconds`);\n",
    "console.log(`Time taken to validate proof with no range bounds ~${verificationTime} seconds`);\n",
    "\n",
    "// Proof creation with one range bounds \n",
    "startTime = performance.now()\n",
    "builder = new PresentationBuilder();\n",
    "builder.addCredential(credential, publicKey)\n",
    "builder.markAttributesRevealed(0, new Set<string>(['credentialSubject.name', 'credentialSubject.profession']));\n",
    "builder.enforceBounds(0, 'credentialSubject.timeOfBirth', new Date(\"1972-01-01T00:00:00\").getTime(), new Date(\"2020-08-01T00:00:00\").getTime(), 'timeOfBirthRangeCheck', snarkProvingKey);\n",
    "presentation = builder.finalize();\n",
    "consumedTime = Math.floor(performance.now() - startTime) / 1000;\n",
    "presentation.verify([publicKey], undefined, new Map([['timeOfBirthRangeCheck', snarkVerifyingKey]]));\n",
    "verificationTime = (Math.floor(performance.now() - startTime - (consumedTime * 1000)) / 1000);\n",
    "LGProofTimes.push(consumedTime);\n",
    "LGVerificationTimes.push(verificationTime);\n",
    "LGProofSizes.push(presentation.proof.bytes.length);\n",
    "console.log(`Proof size with one range bounds is: ${presentation.proof.bytes.length}  bytes`);\n",
    "console.log(`Time taken to generate proof with one range bounds ~${consumedTime} seconds`);\n",
    "console.log(`Time taken to validate proof with no range bounds ~${verificationTime} seconds`);\n",
    "\n",
    "// Proof creation with two range bounds \n",
    "startTime = performance.now()\n",
    "builder = new PresentationBuilder();\n",
    "builder.addCredential(credential, publicKey)\n",
    "builder.markAttributesRevealed(0, new Set<string>(['credentialSubject.name', 'credentialSubject.profession']));\n",
    "builder.enforceBounds(0, 'credentialSubject.timeOfBirth', new Date(\"1972-01-01T00:00:00\").getTime(), new Date(\"2020-08-01T00:00:00\").getTime(), 'timeOfBirthRangeCheck', snarkProvingKey);\n",
    "builder.enforceBounds(0, 'credentialSubject.height', 170, 190, 'heightRangeCheck', snarkProvingKey);\n",
    "presentation = builder.finalize();\n",
    "consumedTime = Math.floor(performance.now() - startTime) / 1000;\n",
    "presentation.verify([publicKey], undefined, new Map([['timeOfBirthRangeCheck', snarkVerifyingKey], ['heightRangeCheck', snarkVerifyingKey]]));\n",
    "verificationTime = (Math.floor(performance.now() - startTime - (consumedTime * 1000)) / 1000);\n",
    "LGProofTimes.push(consumedTime);\n",
    "LGVerificationTimes.push(verificationTime);\n",
    "LGProofSizes.push(presentation.proof.bytes.length);\n",
    "console.log(`Proof size with two range bounds is: ${presentation.proof.bytes.length}  bytes`);\n",
    "console.log(`Time taken to generate proof with two range bounds ~${consumedTime} seconds`);\n",
    "console.log(`Time taken to validate proof with no range bounds ~${verificationTime} seconds`);\n",
    "\n",
    "// Proof creation with three range bounds \n",
    "startTime = performance.now();\n",
    "builder = new PresentationBuilder();\n",
    "builder.addCredential(credential, publicKey);\n",
    "builder.markAttributesRevealed(0, new Set<string>(['credentialSubject.name', 'credentialSubject.profession']));\n",
    "builder.enforceBounds(0, 'credentialSubject.timeOfBirth', new Date(\"1972-01-01T00:00:00\").getTime(), new Date(\"2020-08-01T00:00:00\").getTime(), 'timeOfBirthRangeCheck', snarkProvingKey);\n",
    "builder.enforceBounds(0, 'credentialSubject.height', 170, 190, 'heightRangeCheck', snarkProvingKey);\n",
    "builder.enforceBounds(0, 'credentialSubject.weight', 70, 85, 'weightRangeCheck', snarkProvingKey);\n",
    "\n",
    "presentation = builder.finalize();\n",
    "consumedTime = Math.floor(performance.now() - startTime) / 1000;\n",
    "presentation.verify([publicKey], undefined, new Map([['timeOfBirthRangeCheck', snarkVerifyingKey], ['heightRangeCheck', snarkVerifyingKey], ['weightRangeCheck', snarkVerifyingKey]]));\n",
    "verificationTime = (Math.floor(performance.now() - startTime - (consumedTime * 1000)) / 1000);\n",
    "LGProofTimes.push(consumedTime);\n",
    "LGVerificationTimes.push(verificationTime);\n",
    "LGProofSizes.push(presentation.proof.bytes.length);\n",
    "console.log(`Proof size with three range bounds is: ${presentation.proof.bytes.length}  bytes`);\n",
    "console.log(`Time taken to generate proof with three range bounds ~${consumedTime} seconds`);\n",
    "console.log(`Time taken to validate proof with no range bounds ~${verificationTime} seconds`);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eff84f1a-842e-4c31-9c83-1751fd2ff2d7",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## 3. Bulletproofs++"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e183e475-3bcb-4fe1-9bdf-f74489ecfd3e",
   "metadata": {},
   "outputs": [],
   "source": [
    "// Bulletproofs++\n",
    "import { BoundCheckBppParams, PresentationBuilder } from '@docknetwork/crypto-wasm-ts'\n",
    "\n",
    "// We measure the time taken to create the verification keys\n",
    "let BPProofTimes: number[] = []\n",
    "let BPProofSizes: number[] = []\n",
    "let BPVerificationTimes: number[] = []\n",
    "// BulletProof++ -- setup time\n",
    "let startTime = performance.now();\n",
    "\n",
    "const boundCheckBppParams = new BoundCheckBppParams(stringToBytes('Bulletproofs++ testing')).decompress();\n",
    "const BPSetupTime = Math.floor(performance.now() - startTime) / 1000;\n",
    "\n",
    "BPProofTimes.push(BPSetupTime)\n",
    "console.log(`Time taken to setup BP++: ${BPSetupTime} seconds`)\n",
    "\n",
    "// Proof creation without any range bounds\n",
    "startTime = performance.now()\n",
    "\n",
    "let builder = new PresentationBuilder();\n",
    "builder.addCredential(credential, publicKey)\n",
    "builder.markAttributesRevealed(0, new Set<string>(['credentialSubject.name', 'credentialSubject.profession']));\n",
    "let presentation = builder.finalize();\n",
    "\n",
    "let consumedTime = Math.floor(performance.now() - startTime) / 1000;\n",
    "presentation.verify([publicKey], undefined, undefined)\n",
    "let verificationTime = (Math.floor(performance.now() - startTime - (consumedTime * 1000)) / 1000);\n",
    "BPProofTimes.push(consumedTime);\n",
    "BPVerificationTimes.push(verificationTime);\n",
    "BPProofSizes.push(presentation.proof.bytes.length);\n",
    "console.log(`Proof size without any range bounds is: ${presentation.proof.bytes.length} bytes`);\n",
    "console.log(`Time taken to generate proof with no range bounds ~${consumedTime} seconds`);\n",
    "console.log(`Time taken to validate proof with no range bounds ~${verificationTime} seconds`);\n",
    "\n",
    "// Proof creation with one range bounds \n",
    "startTime = performance.now()\n",
    "builder = new PresentationBuilder();\n",
    "builder.addCredential(credential, publicKey)\n",
    "builder.markAttributesRevealed(0, new Set<string>(['credentialSubject.name', 'credentialSubject.profession']));\n",
    "builder.enforceBounds(\n",
    "    0, 'credentialSubject.timeOfBirth', new Date(\"1972-01-01T00:00:00\").getTime(),\n",
    "    new Date(\"2020-08-01T00:00:00\").getTime(), 'timeOfBirthRangeCheck', boundCheckBppParams\n",
    ");\n",
    "presentation = builder.finalize();\n",
    "consumedTime = Math.floor(performance.now() - startTime) / 1000;\n",
    "presentation.verify([publicKey], undefined, new Map([['timeOfBirthRangeCheck', boundCheckBppParams]]));\n",
    "verificationTime = (Math.floor(performance.now() - startTime - (consumedTime * 1000)) / 1000);\n",
    "BPProofTimes.push(consumedTime);\n",
    "BPVerificationTimes.push(verificationTime);\n",
    "BPProofSizes.push(presentation.proof.bytes.length);\n",
    "console.log(`Proof size with one range bounds is: ${presentation.proof.bytes.length}  bytes`);\n",
    "console.log(`Time taken to generate proof with one range bounds ~${consumedTime} seconds`);\n",
    "console.log(`Time taken to validate proof with no range bounds ~${verificationTime} seconds`);\n",
    "\n",
    "// Proof creation with two range bounds \n",
    "startTime = performance.now()\n",
    "builder = new PresentationBuilder();\n",
    "builder.addCredential(credential, publicKey)\n",
    "builder.markAttributesRevealed(0, new Set<string>(['credentialSubject.name', 'credentialSubject.profession']));\n",
    "builder.enforceBounds(\n",
    "    0, 'credentialSubject.timeOfBirth', new Date(\"1972-01-01T00:00:00\").getTime(),\n",
    "    new Date(\"2020-08-01T00:00:00\").getTime(), 'timeOfBirthRangeCheck', boundCheckBppParams\n",
    ");\n",
    "builder.enforceBounds(0, 'credentialSubject.height', 170, 190, 'heightRangeCheck', boundCheckBppParams);\n",
    "presentation = builder.finalize();\n",
    "consumedTime = Math.floor(performance.now() - startTime) / 1000;\n",
    "presentation.verify([publicKey], undefined, new Map([['timeOfBirthRangeCheck', boundCheckBppParams], ['heightRangeCheck', boundCheckBppParams]]));\n",
    "verificationTime = (Math.floor(performance.now() - startTime - (consumedTime * 1000)) / 1000);\n",
    "BPProofTimes.push(consumedTime);\n",
    "BPVerificationTimes.push(verificationTime);\n",
    "BPProofSizes.push(presentation.proof.bytes.length);\n",
    "console.log(`Proof size with two range bounds is: ${presentation.proof.bytes.length}  bytes`);\n",
    "console.log(`Time taken to generate proof with two range bounds ~${consumedTime} seconds`);\n",
    "console.log(`Time taken to validate proof with no range bounds ~${verificationTime} seconds`);\n",
    "\n",
    "// Proof creation with three range bounds \n",
    "startTime = performance.now()\n",
    "builder = new PresentationBuilder();\n",
    "builder.addCredential(credential, publicKey)\n",
    "builder.markAttributesRevealed(0, new Set<string>(['credentialSubject.name', 'credentialSubject.profession']));\n",
    "builder.enforceBounds(0, 'credentialSubject.timeOfBirth', new Date(\"1972-01-01T00:00:00\").getTime(), new Date(\"2020-08-01T00:00:00\").getTime(), 'timeOfBirthRangeCheck', boundCheckBppParams);\n",
    "builder.enforceBounds(0, 'credentialSubject.height', 170, 190, 'heightRangeCheck', boundCheckBppParams);\n",
    "builder.enforceBounds(0, 'credentialSubject.weight', 70, 85, 'weightRangeCheck', boundCheckBppParams);\n",
    "presentation = builder.finalize();\n",
    "consumedTime = Math.floor(performance.now() - startTime) / 1000;\n",
    "presentation.verify([publicKey], undefined, new Map([['timeOfBirthRangeCheck', boundCheckBppParams], ['heightRangeCheck', boundCheckBppParams], ['weightRangeCheck', boundCheckBppParams]]));\n",
    "verificationTime = (Math.floor(performance.now() - startTime - (consumedTime * 1000)) / 1000);\n",
    "BPProofTimes.push(consumedTime);\n",
    "BPVerificationTimes.push(verificationTime);\n",
    "BPProofSizes.push(presentation.proof.bytes.length);\n",
    "console.log(`Proof size with three range bounds is: ${presentation.proof.bytes.length}  bytes`);\n",
    "console.log(`Time taken to generate proof with three range bounds ~${consumedTime} seconds`);\n",
    "console.log(`Time taken to validate proof with no range bounds ~${verificationTime} seconds`);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bb48469-f48a-4c27-aee6-c963273f9f39",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## 4. Printing values for plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5604e8cc-431a-4244-bfa3-b482dd216fce",
   "metadata": {},
   "outputs": [],
   "source": [
    "console.log(BPProofTimes, LGProofTimes, BPProofSizes, LGProofSizes, BPVerificationTimes, LGVerificationTimes);\n",
    "console.log(provingKey.value.length);"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "TypeScript",
   "language": "typescript",
   "name": "tslab"
  },
  "language_info": {
   "codemirror_mode": {
    "mode": "typescript",
    "name": "javascript",
    "typescript": true
   },
   "file_extension": ".ts",
   "mimetype": "text/typescript",
   "name": "typescript",
   "version": "3.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}