add ProverInput and VerifierInput abstraction

Author: kevaundray

src.ts/index.ts

@@ -7,6 +7,8 @@ import {
   verifyExecutionWitnessPreState as verifyExecutionWitnessPreStateBase,
   createProof as createProofBase,
   verifyProof as verifyProofBase,
+  ProverInput as ProverInputBase,
+  VerifierInput as VerifierInputBase,
 } from './verkleFFIBindings/index.js'
 import { Context as VerkleFFI } from './wasm/rust_verkle_wasm.js'
 
@@ -29,15 +31,18 @@ export const loadVerkleCrypto = async () => {
   ): Commitment =>
     updateCommitmentBase(verkleFFI, commitment, commitmentIndex, oldScalarValue, newScalarValue)
 
-  const verifyExecutionWitnessPreState = (prestateRoot: string, execution_witness_json: string): boolean =>
-    verifyExecutionWitnessPreStateBase(prestateRoot, execution_witness_json)
+  const verifyExecutionWitnessPreState = (
+    prestateRoot: string,
+    execution_witness_json: string,
+  ): boolean => verifyExecutionWitnessPreStateBase(prestateRoot, execution_witness_json)
 
   const zeroCommitment = zeroCommitmentBase()
 
   const hashCommitment = (commitment: Uint8Array) => verkleFFI.hashCommitment(commitment)
   const serializeCommitment = (commitment: Uint8Array) => verkleFFI.serializeCommitment(commitment)
-  const createProof = (input: Uint8Array) => verkleFFI.createProof(input)
-  const verifyProof = (proofInput: Uint8Array) => verkleFFI.verifyProof(proofInput)
+  const createProof = (proverInputs: ProverInput[]) => createProofBase(verkleFFI, proverInputs)
+  const verifyProof = (proof: Uint8Array, verifierInputs: VerifierInput[]) =>
+    verifyProofBase(verkleFFI, proof, verifierInputs)
   return {
     getTreeKey,
     getTreeKeyHash,
@@ -47,13 +52,19 @@ export const loadVerkleCrypto = async () => {
     hashCommitment,
     serializeCommitment,
     createProof,
-    verifyProof
+    verifyProof,
   }
 }
 
+// Input used to create proofs over vectors
+export type ProverInput = ProverInputBase
+// Input needed to verify proofs over vectors
+// alongside the proof.
+export type VerifierInput = VerifierInputBase
+
 // This is a 32 byte serialized field element
 export type Scalar = Uint8Array
 
 // This is a 64 byte serialized point.
 // It is 64 bytes because the point is serialized in uncompressed format.
-export type Commitment = Uint8Array
+export type Commitment = Uint8Array

src.ts/verkleFFIBindings/index.ts

@@ -1,6 +1,18 @@
-import { initVerkleWasm, zeroCommitment, verifyExecutionWitnessPreState } from '../wasm/rust_verkle_wasm.js'
+import {
+  initVerkleWasm,
+  zeroCommitment,
+  verifyExecutionWitnessPreState,
+} from '../wasm/rust_verkle_wasm.js'
 
-import { getTreeKey, getTreeKeyHash, updateCommitment, createProof, verifyProof } from './verkleFFI.js'
+import {
+  getTreeKey,
+  getTreeKeyHash,
+  updateCommitment,
+  createProof,
+  verifyProof,
+  ProverInput,
+  VerifierInput,
+} from './verkleFFI.js'
 
 export {
   initVerkleWasm,
@@ -10,5 +22,7 @@ export {
   zeroCommitment,
   verifyExecutionWitnessPreState,
   createProof,
-  verifyProof
+  verifyProof,
+  ProverInput,
+  VerifierInput,
 }

src.ts/verkleFFIBindings/verkleFFI.ts

@@ -1,3 +1,5 @@
+import { concatBytes } from '@ethereumjs/util'
+
 import { Context as VerkleFFI } from '../wasm/rust_verkle_wasm.js'
 
 // This is equal to 2n + 256n * 64n.
@@ -114,10 +116,65 @@ export function updateCommitment(
   return verkleFFI.updateCommitment(commitment, commitmentIndex, oldScalarValue, newScalarValue)
 }
 
-export function createProof(verkleFFI: VerkleFFI, bytes: Uint8Array): Uint8Array {
-  return verkleFFI.createProof(bytes)
+export function createProof(verkleFFI: VerkleFFI, proverInputs: ProverInput[]): Uint8Array {
+  const serializedProofInputs = serializedProverInputs(proverInputs)
+  return verkleFFI.createProof(serializedProofInputs)
+}
+
+export function verifyProof(
+  verkleFFI: VerkleFFI,
+  proof: Uint8Array,
+  verifierInputs: VerifierInput[],
+): boolean {
+  const serializedVerifierInput = serializeVerifierInputs(proof, verifierInputs)
+  return verkleFFI.verifyProof(serializedVerifierInput)
+}
+
+export interface ProverInput {
+  // Commitment to the vector we want to create a proof for
+  serializedCommitment: Uint8Array
+  // The vector that we want to make proofs over
+  vector: Uint8Array[]
+  // The indices that we want to prove exist in the vector
+  indices: number[]
 }
 
-export function verifyProof(verkleFFI: VerkleFFI, proof: Uint8Array): boolean {
-  return verkleFFI.verifyProof(proof)
-}
+function serializedProverInputs(proofInputs: ProverInput[]): Uint8Array {
+  const serializedProverInputs = proofInputs.flatMap(({ serializedCommitment, vector, indices }) =>
+    indices.flatMap((index) => [
+      serializedCommitment,
+      ...vector,
+      new Uint8Array([index]),
+      vector[index],
+    ]),
+  )
+
+  return concatBytes(...serializedProverInputs)
+}
+
+export interface VerifierInput {
+  // A commitment to the vector that we want to verify
+  // proofs over.
+  serializedCommitment: Uint8Array
+  // A tuple of index and values that we want to verify about the
+  // committed vector.
+  //
+  // ie (index_i, value_i) will verify that the value of the committed
+  // vector at index `index_i` was `value_i`
+  indexValuePairs: Array<{ index: number; value: Uint8Array }>
+}
+
+function serializeVerifierInputs(proof: Uint8Array, verifierInputs: VerifierInput[]): Uint8Array {
+  const serializedVerifierInputs = [
+    proof,
+    ...verifierInputs.flatMap(({ serializedCommitment, indexValuePairs }) =>
+      indexValuePairs.flatMap(({ index, value }) => [
+        serializedCommitment,
+        new Uint8Array([index]),
+        value,
+      ]),
+    ),
+  ]
+
+  return concatBytes(...serializedVerifierInputs)
+}