Add *Proof functions to verkleFFI

src.rs/src/verkle_ffi_api.rs

@@ -1,7 +1,7 @@
 use ffi_interface::Context as InnerContext;
 pub use ffi_interface::{CommitmentBytes, ScalarBytes, ZERO_POINT};
 use ipa_multipoint::committer::Committer;
-use js_sys::Uint8Array;
+use js_sys::{Boolean, Uint8Array};
 use wasm_bindgen::{prelude::wasm_bindgen, JsError, JsValue};
 
 #[wasm_bindgen]
@@ -197,6 +197,31 @@ impl Context {
 
         Ok(bytes_to_js_value(commitment).into())
     }
+
+    /// Create a proof from a serialized array of tuples
+    #[wasm_bindgen(js_name = "createProof")]
+    pub fn create_proof(
+        &self,
+        input: Uint8Array,
+    ) -> Result<Uint8Array, JsError>
+    {
+        let input_bytes = serde_wasm_bindgen::from_value(input.into()).unwrap();
+        let proof = ffi_interface::create_proof(&self.inner, input_bytes).map_err(|err| JsError::new(&format!("could not create proof: {:?}", err)))?;
+        return Ok(Uint8Array::from(&proof[..]));
+    }
+
+    /// Verify a proof created by `createProof`
+    #[wasm_bindgen(js_name = "verifyProof")]
+    pub fn verify_proof(
+        &self,
+        input: Uint8Array,
+    ) -> Result<Boolean, JsError>
+    {
+        let input_bytes = serde_wasm_bindgen::from_value(input.into()).unwrap();
+        let result = ffi_interface::verify_proof(&self.inner, input_bytes).map(|_op |Boolean::from(true))
+        .map_err(|err| JsError::new(&format!("proof verification failed]: {:?}", err)));
+        return result
+    }
 }
 
 /// This is the default commitment to use when nothing has been committed to

src.ts/index.ts

@@ -5,6 +5,8 @@ import {
   updateCommitment as updateCommitmentBase,
   zeroCommitment as zeroCommitmentBase,
   verifyExecutionWitnessPreState as verifyExecutionWitnessPreStateBase,
+  createProof as createProofBase,
+  verifyProof as verifyProofBase,
 } from './verkleFFIBindings/index.js'
 import { Context as VerkleFFI } from './wasm/rust_verkle_wasm.js'
 
@@ -34,14 +36,18 @@ export const loadVerkleCrypto = async () => {
 
   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)
   return {
     getTreeKey,
     getTreeKeyHash,
     updateCommitment,
     zeroCommitment,
     verifyExecutionWitnessPreState,
     hashCommitment,
-    serializeCommitment
+    serializeCommitment,
+    createProof,
+    verifyProof
   }
 }
 

src.ts/verkleFFIBindings/index.ts

@@ -1,12 +1,14 @@
 import { initVerkleWasm, zeroCommitment, verifyExecutionWitnessPreState } from '../wasm/rust_verkle_wasm.js'
 
-import { getTreeKey, getTreeKeyHash, updateCommitment } from './verkleFFI.js'
+import { getTreeKey, getTreeKeyHash, updateCommitment, createProof, verifyProof } from './verkleFFI.js'
 
 export {
   initVerkleWasm,
   getTreeKey,
   getTreeKeyHash,
   updateCommitment,
   zeroCommitment,
-  verifyExecutionWitnessPreState
+  verifyExecutionWitnessPreState,
+  createProof,
+  verifyProof
 }

src.ts/verkleFFIBindings/verkleFFI.ts

@@ -113,3 +113,11 @@ export function updateCommitment(
 ): Uint8Array {
   return verkleFFI.updateCommitment(commitment, commitmentIndex, oldScalarValue, newScalarValue)
 }
+
+export function createProof(verkleFFI: VerkleFFI, bytes: Uint8Array): Uint8Array {
+  return verkleFFI.createProof(bytes)
+}
+
+export function verifyProof(verkleFFI: VerkleFFI, proof: Uint8Array): boolean {
+  return verkleFFI.verifyProof(proof)
+}