@aztec/bb.js 0.0.1-alpha.7 → 0.0.1-fake-ceab37513c

package/src/barretenberg_api/index.ts

@@ -1,649 +1,1216 @@
 // WARNING: FILE CODE GENERATED BY BINDGEN UTILITY. DO NOT EDIT!
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import { BarretenbergBinder, BarretenbergBinderSync } from '../barretenberg_binder/index.js';
+import { BarretenbergWasmMain, BarretenbergWasmMainWorker } from '../barretenberg_wasm/barretenberg_wasm_main/index.js';
 import {
   BufferDeserializer,
   NumberDeserializer,
   VectorDeserializer,
   BoolDeserializer,
   StringDeserializer,
+  serializeBufferable,
+  OutputType,
 } from '../serialize/index.js';
-import { Fr, Fq, Point, Buffer32, Buffer128, Ptr } from '../types/index.js';
+import { Fr, Point, Buffer32, Ptr } from '../types/index.js';
 
 export class BarretenbergApi {
-  constructor(public binder: BarretenbergBinder) {}
+  constructor(protected wasm: BarretenbergWasmMainWorker) {}
+
+  async pedersenCommit(inputsBuffer: Fr[], ctxIndex: number): Promise<Point> {
+    const inArgs = [inputsBuffer, ctxIndex].map(serializeBufferable);
+    const outTypes: OutputType[] = [Point];
+    const result = await this.wasm.callWasmExport(
+      'pedersen_commit',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
 
-  async destroy() {
-    await this.binder.wasm.destroy();
+  async pedersenHash(inputsBuffer: Fr[], hashIndex: number): Promise<Fr> {
+    const inArgs = [inputsBuffer, hashIndex].map(serializeBufferable);
+    const outTypes: OutputType[] = [Fr];
+    const result = await this.wasm.callWasmExport(
+      'pedersen_hash',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async pedersenInit(): Promise<void> {
-    const result = await this.binder.callWasmExport('pedersen___init', [], []);
-    return;
+  async pedersenHashes(inputsBuffer: Fr[], hashIndex: number): Promise<Fr> {
+    const inArgs = [inputsBuffer, hashIndex].map(serializeBufferable);
+    const outTypes: OutputType[] = [Fr];
+    const result = await this.wasm.callWasmExport(
+      'pedersen_hashes',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async pedersenCompressFields(left: Fr, right: Fr): Promise<Fr> {
-    const result = await this.binder.callWasmExport('pedersen___compress_fields', [left, right], [Fr]);
-    return result[0];
+  async pedersenHashBuffer(inputBuffer: Uint8Array, hashIndex: number): Promise<Fr> {
+    const inArgs = [inputBuffer, hashIndex].map(serializeBufferable);
+    const outTypes: OutputType[] = [Fr];
+    const result = await this.wasm.callWasmExport(
+      'pedersen_hash_buffer',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async pedersenPlookupCompressFields(left: Fr, right: Fr): Promise<Fr> {
-    const result = await this.binder.callWasmExport('pedersen___plookup_compress_fields', [left, right], [Fr]);
-    return result[0];
+  async poseidon2Hash(inputsBuffer: Fr[]): Promise<Fr> {
+    const inArgs = [inputsBuffer].map(serializeBufferable);
+    const outTypes: OutputType[] = [Fr];
+    const result = await this.wasm.callWasmExport(
+      'poseidon2_hash',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async pedersenCompress(inputsBuffer: Fr[]): Promise<Fr> {
-    const result = await this.binder.callWasmExport('pedersen___compress', [inputsBuffer], [Fr]);
-    return result[0];
+  async poseidon2Hashes(inputsBuffer: Fr[]): Promise<Fr> {
+    const inArgs = [inputsBuffer].map(serializeBufferable);
+    const outTypes: OutputType[] = [Fr];
+    const result = await this.wasm.callWasmExport(
+      'poseidon2_hashes',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async pedersenPlookupCompress(inputsBuffer: Fr[]): Promise<Fr> {
-    const result = await this.binder.callWasmExport('pedersen___plookup_compress', [inputsBuffer], [Fr]);
-    return result[0];
+  async poseidon2Permutation(inputsBuffer: Fr[]): Promise<Fr[]> {
+    const inArgs = [inputsBuffer].map(serializeBufferable);
+    const outTypes: OutputType[] = [VectorDeserializer(Fr)];
+    const result = await this.wasm.callWasmExport(
+      'poseidon2_permutation',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async pedersenCompressWithHashIndex(inputsBuffer: Fr[], hashIndex: number): Promise<Fr> {
-    const result = await this.binder.callWasmExport(
-      'pedersen___compress_with_hash_index',
-      [inputsBuffer, hashIndex],
-      [Fr],
+  async poseidon2HashAccumulate(inputsBuffer: Fr[]): Promise<Fr> {
+    const inArgs = [inputsBuffer].map(serializeBufferable);
+    const outTypes: OutputType[] = [Fr];
+    const result = await this.wasm.callWasmExport(
+      'poseidon2_hash_accumulate',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result[0];
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async pedersenCommit(inputsBuffer: Fr[]): Promise<Fr> {
-    const result = await this.binder.callWasmExport('pedersen___commit', [inputsBuffer], [Fr]);
-    return result[0];
+  async blake2s(data: Uint8Array): Promise<Buffer32> {
+    const inArgs = [data].map(serializeBufferable);
+    const outTypes: OutputType[] = [Buffer32];
+    const result = await this.wasm.callWasmExport(
+      'blake2s',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async pedersenPlookupCommit(inputsBuffer: Fr[]): Promise<Fr> {
-    const result = await this.binder.callWasmExport('pedersen___plookup_commit', [inputsBuffer], [Fr]);
-    return result[0];
+  async blake2sToField(data: Uint8Array): Promise<Fr> {
+    const inArgs = [data].map(serializeBufferable);
+    const outTypes: OutputType[] = [Fr];
+    const result = await this.wasm.callWasmExport(
+      'blake2s_to_field_',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async pedersenPlookupCommitWithHashIndex(inputsBuffer: Fr[], hashIndex: number): Promise<Fr> {
-    const result = await this.binder.callWasmExport(
-      'pedersen___plookup_commit_with_hash_index',
-      [inputsBuffer, hashIndex],
-      [Fr],
+  async aesEncryptBufferCbc(input: Uint8Array, iv: Uint8Array, key: Uint8Array, length: number): Promise<Uint8Array> {
+    const inArgs = [input, iv, key, length].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'aes_encrypt_buffer_cbc',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result[0];
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async pedersenBufferToField(data: Uint8Array): Promise<Fr> {
-    const result = await this.binder.callWasmExport('pedersen___buffer_to_field', [data], [Fr]);
-    return result[0];
+  async aesDecryptBufferCbc(input: Uint8Array, iv: Uint8Array, key: Uint8Array, length: number): Promise<Uint8Array> {
+    const inArgs = [input, iv, key, length].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'aes_decrypt_buffer_cbc',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async pedersenHashInit(): Promise<void> {
-    const result = await this.binder.callWasmExport('pedersen_hash_init', [], []);
+  async srsInitSrs(pointsBuf: Uint8Array, numPoints: number, g2PointBuf: Uint8Array): Promise<void> {
+    const inArgs = [pointsBuf, numPoints, g2PointBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [];
+    const result = await this.wasm.callWasmExport(
+      'srs_init_srs',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
     return;
   }
 
-  async pedersenHashPair(left: Fr, right: Fr): Promise<Fr> {
-    const result = await this.binder.callWasmExport('pedersen_hash_pair', [left, right], [Fr]);
-    return result[0];
+  async srsInitGrumpkinSrs(pointsBuf: Uint8Array, numPoints: number): Promise<void> {
+    const inArgs = [pointsBuf, numPoints].map(serializeBufferable);
+    const outTypes: OutputType[] = [];
+    const result = await this.wasm.callWasmExport(
+      'srs_init_grumpkin_srs',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return;
   }
 
-  async pedersenHashMultiple(inputsBuffer: Fr[]): Promise<Fr> {
-    const result = await this.binder.callWasmExport('pedersen_hash_multiple', [inputsBuffer], [Fr]);
-    return result[0];
+  async testThreads(threads: number, iterations: number): Promise<number> {
+    const inArgs = [threads, iterations].map(serializeBufferable);
+    const outTypes: OutputType[] = [NumberDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'test_threads',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async pedersenHashMultipleWithHashIndex(inputsBuffer: Fr[], hashIndex: number): Promise<Fr> {
-    const result = await this.binder.callWasmExport(
-      'pedersen_hash_multiple_with_hash_index',
-      [inputsBuffer, hashIndex],
-      [Fr],
+  async commonInitSlabAllocator(circuitSize: number): Promise<void> {
+    const inArgs = [circuitSize].map(serializeBufferable);
+    const outTypes: OutputType[] = [];
+    const result = await this.wasm.callWasmExport(
+      'common_init_slab_allocator',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result[0];
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return;
   }
 
-  async pedersenHashToTree(data: Fr[]): Promise<Fr[]> {
-    const result = await this.binder.callWasmExport('pedersen_hash_to_tree', [data], [VectorDeserializer(Fr)]);
-    return result[0];
+  async acirGetCircuitSizes(
+    constraintSystemBuf: Uint8Array,
+    recursive: boolean,
+    honkRecursion: boolean,
+  ): Promise<[number, number]> {
+    const inArgs = [constraintSystemBuf, recursive, honkRecursion].map(serializeBufferable);
+    const outTypes: OutputType[] = [NumberDeserializer(), NumberDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_get_circuit_sizes',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out as any;
   }
 
-  async blake2s(data: Uint8Array): Promise<Buffer32> {
-    const result = await this.binder.callWasmExport('blake2s', [data], [Buffer32]);
-    return result[0];
+  async acirProveAndVerifyUltraHonk(constraintSystemBuf: Uint8Array, witnessBuf: Uint8Array): Promise<boolean> {
+    const inArgs = [constraintSystemBuf, witnessBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BoolDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_prove_and_verify_ultra_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async blake2sToField(data: Uint8Array): Promise<Fr> {
-    const result = await this.binder.callWasmExport('blake2s_to_field_', [data], [Fr]);
-    return result[0];
+  async acirProveAndVerifyMegaHonk(constraintSystemBuf: Uint8Array, witnessBuf: Uint8Array): Promise<boolean> {
+    const inArgs = [constraintSystemBuf, witnessBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BoolDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_prove_and_verify_mega_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async schnorrComputePublicKey(privateKey: Fr): Promise<Point> {
-    const result = await this.binder.callWasmExport('schnorr_compute_public_key', [privateKey], [Point]);
-    return result[0];
+  async acirProveAztecClient(ivcInputsBuf: Uint8Array): Promise<[Uint8Array, Uint8Array]> {
+    const inArgs = [ivcInputsBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer(), BufferDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_prove_aztec_client',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out as any;
   }
 
-  async schnorrNegatePublicKey(publicKeyBuffer: Point): Promise<Point> {
-    const result = await this.binder.callWasmExport('schnorr_negate_public_key', [publicKeyBuffer], [Point]);
-    return result[0];
+  async acirVerifyAztecClient(proofBuf: Uint8Array, vkBuf: Uint8Array): Promise<boolean> {
+    const inArgs = [proofBuf, vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BoolDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_verify_aztec_client',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async schnorrConstructSignature(message: Uint8Array, privateKey: Fr): Promise<[Buffer32, Buffer32]> {
-    const result = await this.binder.callWasmExport(
-      'schnorr_construct_signature',
-      [message, privateKey],
-      [Buffer32, Buffer32],
+  async acirLoadVerificationKey(acirComposerPtr: Ptr, vkBuf: Uint8Array): Promise<void> {
+    const inArgs = [acirComposerPtr, vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [];
+    const result = await this.wasm.callWasmExport(
+      'acir_load_verification_key',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result as any;
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return;
   }
 
-  async schnorrVerifySignature(message: Uint8Array, pubKey: Point, sigS: Buffer32, sigE: Buffer32): Promise<boolean> {
-    const result = await this.binder.callWasmExport(
-      'schnorr_verify_signature',
-      [message, pubKey, sigS, sigE],
-      [BoolDeserializer()],
+  async acirInitVerificationKey(acirComposerPtr: Ptr): Promise<void> {
+    const inArgs = [acirComposerPtr].map(serializeBufferable);
+    const outTypes: OutputType[] = [];
+    const result = await this.wasm.callWasmExport(
+      'acir_init_verification_key',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result[0];
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return;
   }
 
-  async schnorrMultisigCreateMultisigPublicKey(privateKey: Fq): Promise<Buffer128> {
-    const result = await this.binder.callWasmExport(
-      'schnorr_multisig_create_multisig_public_key',
-      [privateKey],
-      [Buffer128],
+  async acirGetVerificationKey(acirComposerPtr: Ptr): Promise<Uint8Array> {
+    const inArgs = [acirComposerPtr].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_get_verification_key',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result[0];
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async schnorrMultisigValidateAndCombineSignerPubkeys(signerPubkeyBuf: Buffer128[]): Promise<[Point, boolean]> {
-    const result = await this.binder.callWasmExport(
-      'schnorr_multisig_validate_and_combine_signer_pubkeys',
-      [signerPubkeyBuf],
-      [Point, BoolDeserializer()],
+  async acirGetProvingKey(acirComposerPtr: Ptr, acirVec: Uint8Array, recursive: boolean): Promise<Uint8Array> {
+    const inArgs = [acirComposerPtr, acirVec, recursive].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_get_proving_key',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result as any;
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async schnorrMultisigConstructSignatureRound1(): Promise<[Buffer128, Buffer128]> {
-    const result = await this.binder.callWasmExport(
-      'schnorr_multisig_construct_signature_round_1',
-      [],
-      [Buffer128, Buffer128],
+  async acirVerifyProof(acirComposerPtr: Ptr, proofBuf: Uint8Array): Promise<boolean> {
+    const inArgs = [acirComposerPtr, proofBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BoolDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_verify_proof',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result as any;
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async schnorrMultisigConstructSignatureRound2(
-    message: Uint8Array,
-    privateKey: Fq,
-    signerRoundOnePrivateBuf: Buffer128,
-    signerPubkeysBuf: Buffer128[],
-    roundOnePublicBuf: Buffer128[],
-  ): Promise<[Fq, boolean]> {
-    const result = await this.binder.callWasmExport(
-      'schnorr_multisig_construct_signature_round_2',
-      [message, privateKey, signerRoundOnePrivateBuf, signerPubkeysBuf, roundOnePublicBuf],
-      [Fq, BoolDeserializer()],
+  async acirGetSolidityVerifier(acirComposerPtr: Ptr): Promise<string> {
+    const inArgs = [acirComposerPtr].map(serializeBufferable);
+    const outTypes: OutputType[] = [StringDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_get_solidity_verifier',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result as any;
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async schnorrMultisigCombineSignatures(
-    message: Uint8Array,
-    signerPubkeysBuf: Buffer128[],
-    roundOneBuf: Buffer128[],
-    roundTwoBuf: Fr[],
-  ): Promise<[Buffer32, Buffer32, boolean]> {
-    const result = await this.binder.callWasmExport(
-      'schnorr_multisig_combine_signatures',
-      [message, signerPubkeysBuf, roundOneBuf, roundTwoBuf],
-      [Buffer32, Buffer32, BoolDeserializer()],
+  async acirHonkSolidityVerifier(proofBuf: Uint8Array, vkBuf: Uint8Array): Promise<string> {
+    const inArgs = [proofBuf, vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [StringDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_honk_solidity_verifier',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result as any;
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async srsInitSrs(pointsBuf: Uint8Array, numPoints: number, g2PointBuf: Uint8Array): Promise<void> {
-    const result = await this.binder.callWasmExport('srs_init_srs', [pointsBuf, numPoints, g2PointBuf], []);
-    return;
+  async acirSerializeProofIntoFields(
+    acirComposerPtr: Ptr,
+    proofBuf: Uint8Array,
+    numInnerPublicInputs: number,
+  ): Promise<Fr[]> {
+    const inArgs = [acirComposerPtr, proofBuf, numInnerPublicInputs].map(serializeBufferable);
+    const outTypes: OutputType[] = [VectorDeserializer(Fr)];
+    const result = await this.wasm.callWasmExport(
+      'acir_serialize_proof_into_fields',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async examplesSimpleCreateAndVerifyProof(): Promise<boolean> {
-    const result = await this.binder.callWasmExport(
-      'examples_simple_create_and_verify_proof',
-      [],
-      [BoolDeserializer()],
+  async acirSerializeVerificationKeyIntoFields(acirComposerPtr: Ptr): Promise<[Fr[], Fr]> {
+    const inArgs = [acirComposerPtr].map(serializeBufferable);
+    const outTypes: OutputType[] = [VectorDeserializer(Fr), Fr];
+    const result = await this.wasm.callWasmExport(
+      'acir_serialize_verification_key_into_fields',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result[0];
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out as any;
   }
 
-  async testThreads(threads: number, iterations: number): Promise<number> {
-    const result = await this.binder.callWasmExport('test_threads', [threads, iterations], [NumberDeserializer()]);
-    return result[0];
+  async acirProveUltraZKHonk(acirVec: Uint8Array, witnessVec: Uint8Array, vkBuf: Uint8Array): Promise<Uint8Array> {
+    const inArgs = [acirVec, witnessVec, vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_prove_ultra_zk_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async testThreadAbort(): Promise<void> {
-    const result = await this.binder.callWasmExport('test_thread_abort', [], []);
-    return;
+  async acirProveUltraKeccakHonk(acirVec: Uint8Array, witnessVec: Uint8Array, vkBuf: Uint8Array): Promise<Uint8Array> {
+    const inArgs = [acirVec, witnessVec, vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_prove_ultra_keccak_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async testAbort(): Promise<void> {
-    const result = await this.binder.callWasmExport('test_abort', [], []);
-    return;
+  async acirProveUltraKeccakZkHonk(
+    acirVec: Uint8Array,
+    witnessVec: Uint8Array,
+    vkBuf: Uint8Array,
+  ): Promise<Uint8Array> {
+    const inArgs = [acirVec, witnessVec, vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_prove_ultra_keccak_zk_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async commonInitSlabAllocator(circuitSize: number): Promise<void> {
-    const result = await this.binder.callWasmExport('common_init_slab_allocator', [circuitSize], []);
-    return;
+  async acirProveUltraStarknetHonk(
+    acirVec: Uint8Array,
+    witnessVec: Uint8Array,
+    vkBuf: Uint8Array,
+  ): Promise<Uint8Array> {
+    const inArgs = [acirVec, witnessVec, vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_prove_ultra_starknet_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async acirGetCircuitSizes(constraintSystemBuf: Uint8Array): Promise<[number, number, number]> {
-    const result = await this.binder.callWasmExport(
-      'acir_get_circuit_sizes',
-      [constraintSystemBuf],
-      [NumberDeserializer(), NumberDeserializer(), NumberDeserializer()],
+  async acirProveUltraStarknetZkHonk(
+    acirVec: Uint8Array,
+    witnessVec: Uint8Array,
+    vkBuf: Uint8Array,
+  ): Promise<Uint8Array> {
+    const inArgs = [acirVec, witnessVec, vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_prove_ultra_starknet_zk_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result as any;
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async acirNewAcirComposer(sizeHint: number): Promise<Ptr> {
-    const result = await this.binder.callWasmExport('acir_new_acir_composer', [sizeHint], [Ptr]);
-    return result[0];
+  async acirVerifyUltraZKHonk(proofBuf: Uint8Array, vkBuf: Uint8Array): Promise<boolean> {
+    const inArgs = [proofBuf, vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BoolDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_verify_ultra_zk_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async acirDeleteAcirComposer(acirComposerPtr: Ptr): Promise<void> {
-    const result = await this.binder.callWasmExport('acir_delete_acir_composer', [acirComposerPtr], []);
-    return;
+  async acirVerifyUltraKeccakHonk(proofBuf: Uint8Array, vkBuf: Uint8Array): Promise<boolean> {
+    const inArgs = [proofBuf, vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BoolDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_verify_ultra_keccak_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async acirCreateCircuit(acirComposerPtr: Ptr, constraintSystemBuf: Uint8Array, sizeHint: number): Promise<void> {
-    const result = await this.binder.callWasmExport(
-      'acir_create_circuit',
-      [acirComposerPtr, constraintSystemBuf, sizeHint],
-      [],
+  async acirVerifyUltraKeccakZkHonk(proofBuf: Uint8Array, vkBuf: Uint8Array): Promise<boolean> {
+    const inArgs = [proofBuf, vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BoolDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_verify_ultra_keccak_zk_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return;
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async acirInitProvingKey(acirComposerPtr: Ptr, constraintSystemBuf: Uint8Array): Promise<void> {
-    const result = await this.binder.callWasmExport(
-      'acir_init_proving_key',
-      [acirComposerPtr, constraintSystemBuf],
-      [],
+  async acirVerifyUltraStarknetHonk(proofBuf: Uint8Array, vkBuf: Uint8Array): Promise<boolean> {
+    const inArgs = [proofBuf, vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BoolDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_verify_ultra_starknet_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return;
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async acirCreateProof(
-    acirComposerPtr: Ptr,
-    constraintSystemBuf: Uint8Array,
-    witnessBuf: Uint8Array,
-    isRecursive: boolean,
-  ): Promise<Uint8Array> {
-    const result = await this.binder.callWasmExport(
-      'acir_create_proof',
-      [acirComposerPtr, constraintSystemBuf, witnessBuf, isRecursive],
-      [BufferDeserializer()],
+  async acirVerifyUltraStarknetZkHonk(proofBuf: Uint8Array, vkBuf: Uint8Array): Promise<boolean> {
+    const inArgs = [proofBuf, vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BoolDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_verify_ultra_starknet_zk_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result[0];
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async acirLoadVerificationKey(acirComposerPtr: Ptr, vkBuf: Uint8Array): Promise<void> {
-    const result = await this.binder.callWasmExport('acir_load_verification_key', [acirComposerPtr, vkBuf], []);
-    return;
+  async acirWriteVkUltraHonk(acirVec: Uint8Array): Promise<Uint8Array> {
+    const inArgs = [acirVec].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_write_vk_ultra_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async acirInitVerificationKey(acirComposerPtr: Ptr): Promise<void> {
-    const result = await this.binder.callWasmExport('acir_init_verification_key', [acirComposerPtr], []);
-    return;
+  async acirWriteVkUltraKeccakHonk(acirVec: Uint8Array): Promise<Uint8Array> {
+    const inArgs = [acirVec].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_write_vk_ultra_keccak_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async acirGetVerificationKey(acirComposerPtr: Ptr): Promise<Uint8Array> {
-    const result = await this.binder.callWasmExport(
-      'acir_get_verification_key',
-      [acirComposerPtr],
-      [BufferDeserializer()],
+  async acirWriteVkUltraKeccakZkHonk(acirVec: Uint8Array): Promise<Uint8Array> {
+    const inArgs = [acirVec].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_write_vk_ultra_keccak_zk_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result[0];
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async acirVerifyProof(acirComposerPtr: Ptr, proofBuf: Uint8Array, isRecursive: boolean): Promise<boolean> {
-    const result = await this.binder.callWasmExport(
-      'acir_verify_proof',
-      [acirComposerPtr, proofBuf, isRecursive],
-      [BoolDeserializer()],
+  async acirWriteVkUltraStarknetHonk(acirVec: Uint8Array): Promise<Uint8Array> {
+    const inArgs = [acirVec].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_write_vk_ultra_starknet_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result[0];
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async acirGetSolidityVerifier(acirComposerPtr: Ptr): Promise<string> {
-    const result = await this.binder.callWasmExport(
-      'acir_get_solidity_verifier',
-      [acirComposerPtr],
-      [StringDeserializer()],
+  async acirWriteVkUltraStarknetZkHonk(acirVec: Uint8Array): Promise<Uint8Array> {
+    const inArgs = [acirVec].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_write_vk_ultra_starknet_zk_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result[0];
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async acirSerializeProofIntoFields(
-    acirComposerPtr: Ptr,
-    proofBuf: Uint8Array,
-    numInnerPublicInputs: number,
-  ): Promise<Fr[]> {
-    const result = await this.binder.callWasmExport(
-      'acir_serialize_proof_into_fields',
-      [acirComposerPtr, proofBuf, numInnerPublicInputs],
-      [VectorDeserializer(Fr)],
+  async acirProofAsFieldsUltraHonk(proofBuf: Uint8Array): Promise<Fr[]> {
+    const inArgs = [proofBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [VectorDeserializer(Fr)];
+    const result = await this.wasm.callWasmExport(
+      'acir_proof_as_fields_ultra_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result[0];
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  async acirSerializeVerificationKeyIntoFields(acirComposerPtr: Ptr): Promise<[Fr[], Fr]> {
-    const result = await this.binder.callWasmExport(
-      'acir_serialize_verification_key_into_fields',
-      [acirComposerPtr],
-      [VectorDeserializer(Fr), Fr],
+  async acirVkAsFieldsUltraHonk(vkBuf: Uint8Array): Promise<Fr[]> {
+    const inArgs = [vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [VectorDeserializer(Fr)];
+    const result = await this.wasm.callWasmExport(
+      'acir_vk_as_fields_ultra_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result as any;
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+
+  async acirVkAsFieldsMegaHonk(vkBuf: Uint8Array): Promise<Fr[]> {
+    const inArgs = [vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [VectorDeserializer(Fr)];
+    const result = await this.wasm.callWasmExport(
+      'acir_vk_as_fields_mega_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
-}
 
+  async acirGatesAztecClient(ivcInputsBuf: Uint8Array): Promise<Uint8Array> {
+    const inArgs = [ivcInputsBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_gates_aztec_client',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+}
 export class BarretenbergApiSync {
-  constructor(public binder: BarretenbergBinderSync) {}
+  constructor(protected wasm: BarretenbergWasmMain) {}
+
+  pedersenCommit(inputsBuffer: Fr[], ctxIndex: number): Point {
+    const inArgs = [inputsBuffer, ctxIndex].map(serializeBufferable);
+    const outTypes: OutputType[] = [Point];
+    const result = this.wasm.callWasmExport(
+      'pedersen_commit',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
 
-  async destroy() {
-    await this.binder.wasm.destroy();
+  pedersenHash(inputsBuffer: Fr[], hashIndex: number): Fr {
+    const inArgs = [inputsBuffer, hashIndex].map(serializeBufferable);
+    const outTypes: OutputType[] = [Fr];
+    const result = this.wasm.callWasmExport(
+      'pedersen_hash',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  pedersenInit(): void {
-    const result = this.binder.callWasmExport('pedersen___init', [], []);
-    return;
+  pedersenHashes(inputsBuffer: Fr[], hashIndex: number): Fr {
+    const inArgs = [inputsBuffer, hashIndex].map(serializeBufferable);
+    const outTypes: OutputType[] = [Fr];
+    const result = this.wasm.callWasmExport(
+      'pedersen_hashes',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  pedersenCompressFields(left: Fr, right: Fr): Fr {
-    const result = this.binder.callWasmExport('pedersen___compress_fields', [left, right], [Fr]);
-    return result[0];
+  pedersenHashBuffer(inputBuffer: Uint8Array, hashIndex: number): Fr {
+    const inArgs = [inputBuffer, hashIndex].map(serializeBufferable);
+    const outTypes: OutputType[] = [Fr];
+    const result = this.wasm.callWasmExport(
+      'pedersen_hash_buffer',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  pedersenPlookupCompressFields(left: Fr, right: Fr): Fr {
-    const result = this.binder.callWasmExport('pedersen___plookup_compress_fields', [left, right], [Fr]);
-    return result[0];
+  poseidon2Hash(inputsBuffer: Fr[]): Fr {
+    const inArgs = [inputsBuffer].map(serializeBufferable);
+    const outTypes: OutputType[] = [Fr];
+    const result = this.wasm.callWasmExport(
+      'poseidon2_hash',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  pedersenCompress(inputsBuffer: Fr[]): Fr {
-    const result = this.binder.callWasmExport('pedersen___compress', [inputsBuffer], [Fr]);
-    return result[0];
+  poseidon2Hashes(inputsBuffer: Fr[]): Fr {
+    const inArgs = [inputsBuffer].map(serializeBufferable);
+    const outTypes: OutputType[] = [Fr];
+    const result = this.wasm.callWasmExport(
+      'poseidon2_hashes',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  pedersenPlookupCompress(inputsBuffer: Fr[]): Fr {
-    const result = this.binder.callWasmExport('pedersen___plookup_compress', [inputsBuffer], [Fr]);
-    return result[0];
+  poseidon2Permutation(inputsBuffer: Fr[]): Fr[] {
+    const inArgs = [inputsBuffer].map(serializeBufferable);
+    const outTypes: OutputType[] = [VectorDeserializer(Fr)];
+    const result = this.wasm.callWasmExport(
+      'poseidon2_permutation',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  pedersenCompressWithHashIndex(inputsBuffer: Fr[], hashIndex: number): Fr {
-    const result = this.binder.callWasmExport('pedersen___compress_with_hash_index', [inputsBuffer, hashIndex], [Fr]);
-    return result[0];
+  poseidon2HashAccumulate(inputsBuffer: Fr[]): Fr {
+    const inArgs = [inputsBuffer].map(serializeBufferable);
+    const outTypes: OutputType[] = [Fr];
+    const result = this.wasm.callWasmExport(
+      'poseidon2_hash_accumulate',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  pedersenCommit(inputsBuffer: Fr[]): Fr {
-    const result = this.binder.callWasmExport('pedersen___commit', [inputsBuffer], [Fr]);
-    return result[0];
+  blake2s(data: Uint8Array): Buffer32 {
+    const inArgs = [data].map(serializeBufferable);
+    const outTypes: OutputType[] = [Buffer32];
+    const result = this.wasm.callWasmExport(
+      'blake2s',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  pedersenPlookupCommit(inputsBuffer: Fr[]): Fr {
-    const result = this.binder.callWasmExport('pedersen___plookup_commit', [inputsBuffer], [Fr]);
-    return result[0];
+  blake2sToField(data: Uint8Array): Fr {
+    const inArgs = [data].map(serializeBufferable);
+    const outTypes: OutputType[] = [Fr];
+    const result = this.wasm.callWasmExport(
+      'blake2s_to_field_',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  pedersenPlookupCommitWithHashIndex(inputsBuffer: Fr[], hashIndex: number): Fr {
-    const result = this.binder.callWasmExport(
-      'pedersen___plookup_commit_with_hash_index',
-      [inputsBuffer, hashIndex],
-      [Fr],
+  aesEncryptBufferCbc(input: Uint8Array, iv: Uint8Array, key: Uint8Array, length: number): Uint8Array {
+    const inArgs = [input, iv, key, length].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'aes_encrypt_buffer_cbc',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result[0];
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  pedersenBufferToField(data: Uint8Array): Fr {
-    const result = this.binder.callWasmExport('pedersen___buffer_to_field', [data], [Fr]);
-    return result[0];
+  aesDecryptBufferCbc(input: Uint8Array, iv: Uint8Array, key: Uint8Array, length: number): Uint8Array {
+    const inArgs = [input, iv, key, length].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'aes_decrypt_buffer_cbc',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  pedersenHashInit(): void {
-    const result = this.binder.callWasmExport('pedersen_hash_init', [], []);
+  srsInitSrs(pointsBuf: Uint8Array, numPoints: number, g2PointBuf: Uint8Array): void {
+    const inArgs = [pointsBuf, numPoints, g2PointBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [];
+    const result = this.wasm.callWasmExport(
+      'srs_init_srs',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
     return;
   }
 
-  pedersenHashPair(left: Fr, right: Fr): Fr {
-    const result = this.binder.callWasmExport('pedersen_hash_pair', [left, right], [Fr]);
-    return result[0];
+  srsInitGrumpkinSrs(pointsBuf: Uint8Array, numPoints: number): void {
+    const inArgs = [pointsBuf, numPoints].map(serializeBufferable);
+    const outTypes: OutputType[] = [];
+    const result = this.wasm.callWasmExport(
+      'srs_init_grumpkin_srs',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return;
   }
 
-  pedersenHashMultiple(inputsBuffer: Fr[]): Fr {
-    const result = this.binder.callWasmExport('pedersen_hash_multiple', [inputsBuffer], [Fr]);
-    return result[0];
+  testThreads(threads: number, iterations: number): number {
+    const inArgs = [threads, iterations].map(serializeBufferable);
+    const outTypes: OutputType[] = [NumberDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'test_threads',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  pedersenHashMultipleWithHashIndex(inputsBuffer: Fr[], hashIndex: number): Fr {
-    const result = this.binder.callWasmExport(
-      'pedersen_hash_multiple_with_hash_index',
-      [inputsBuffer, hashIndex],
-      [Fr],
+  commonInitSlabAllocator(circuitSize: number): void {
+    const inArgs = [circuitSize].map(serializeBufferable);
+    const outTypes: OutputType[] = [];
+    const result = this.wasm.callWasmExport(
+      'common_init_slab_allocator',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result[0];
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return;
   }
 
-  pedersenHashToTree(data: Fr[]): Fr[] {
-    const result = this.binder.callWasmExport('pedersen_hash_to_tree', [data], [VectorDeserializer(Fr)]);
-    return result[0];
+  acirGetCircuitSizes(constraintSystemBuf: Uint8Array, recursive: boolean, honkRecursion: boolean): [number, number] {
+    const inArgs = [constraintSystemBuf, recursive, honkRecursion].map(serializeBufferable);
+    const outTypes: OutputType[] = [NumberDeserializer(), NumberDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_get_circuit_sizes',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out as any;
   }
 
-  blake2s(data: Uint8Array): Buffer32 {
-    const result = this.binder.callWasmExport('blake2s', [data], [Buffer32]);
-    return result[0];
+  acirProveAndVerifyUltraHonk(constraintSystemBuf: Uint8Array, witnessBuf: Uint8Array): boolean {
+    const inArgs = [constraintSystemBuf, witnessBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BoolDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_prove_and_verify_ultra_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  blake2sToField(data: Uint8Array): Fr {
-    const result = this.binder.callWasmExport('blake2s_to_field_', [data], [Fr]);
-    return result[0];
+  acirProveAndVerifyMegaHonk(constraintSystemBuf: Uint8Array, witnessBuf: Uint8Array): boolean {
+    const inArgs = [constraintSystemBuf, witnessBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BoolDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_prove_and_verify_mega_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  schnorrComputePublicKey(privateKey: Fr): Point {
-    const result = this.binder.callWasmExport('schnorr_compute_public_key', [privateKey], [Point]);
-    return result[0];
+  acirProveAztecClient(ivcInputsBuf: Uint8Array): [Uint8Array, Uint8Array] {
+    const inArgs = [ivcInputsBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer(), BufferDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_prove_aztec_client',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out as any;
   }
 
-  schnorrNegatePublicKey(publicKeyBuffer: Point): Point {
-    const result = this.binder.callWasmExport('schnorr_negate_public_key', [publicKeyBuffer], [Point]);
-    return result[0];
+  acirVerifyAztecClient(proofBuf: Uint8Array, vkBuf: Uint8Array): boolean {
+    const inArgs = [proofBuf, vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BoolDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_verify_aztec_client',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  schnorrConstructSignature(message: Uint8Array, privateKey: Fr): [Buffer32, Buffer32] {
-    const result = this.binder.callWasmExport(
-      'schnorr_construct_signature',
-      [message, privateKey],
-      [Buffer32, Buffer32],
+  acirLoadVerificationKey(acirComposerPtr: Ptr, vkBuf: Uint8Array): void {
+    const inArgs = [acirComposerPtr, vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [];
+    const result = this.wasm.callWasmExport(
+      'acir_load_verification_key',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result as any;
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return;
   }
 
-  schnorrVerifySignature(message: Uint8Array, pubKey: Point, sigS: Buffer32, sigE: Buffer32): boolean {
-    const result = this.binder.callWasmExport(
-      'schnorr_verify_signature',
-      [message, pubKey, sigS, sigE],
-      [BoolDeserializer()],
+  acirInitVerificationKey(acirComposerPtr: Ptr): void {
+    const inArgs = [acirComposerPtr].map(serializeBufferable);
+    const outTypes: OutputType[] = [];
+    const result = this.wasm.callWasmExport(
+      'acir_init_verification_key',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result[0];
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return;
   }
 
-  schnorrMultisigCreateMultisigPublicKey(privateKey: Fq): Buffer128 {
-    const result = this.binder.callWasmExport('schnorr_multisig_create_multisig_public_key', [privateKey], [Buffer128]);
-    return result[0];
+  acirGetVerificationKey(acirComposerPtr: Ptr): Uint8Array {
+    const inArgs = [acirComposerPtr].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_get_verification_key',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  schnorrMultisigValidateAndCombineSignerPubkeys(signerPubkeyBuf: Buffer128[]): [Point, boolean] {
-    const result = this.binder.callWasmExport(
-      'schnorr_multisig_validate_and_combine_signer_pubkeys',
-      [signerPubkeyBuf],
-      [Point, BoolDeserializer()],
+  acirGetProvingKey(acirComposerPtr: Ptr, acirVec: Uint8Array, recursive: boolean): Uint8Array {
+    const inArgs = [acirComposerPtr, acirVec, recursive].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_get_proving_key',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result as any;
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  schnorrMultisigConstructSignatureRound1(): [Buffer128, Buffer128] {
-    const result = this.binder.callWasmExport(
-      'schnorr_multisig_construct_signature_round_1',
-      [],
-      [Buffer128, Buffer128],
+  acirVerifyProof(acirComposerPtr: Ptr, proofBuf: Uint8Array): boolean {
+    const inArgs = [acirComposerPtr, proofBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BoolDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_verify_proof',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result as any;
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  schnorrMultisigConstructSignatureRound2(
-    message: Uint8Array,
-    privateKey: Fq,
-    signerRoundOnePrivateBuf: Buffer128,
-    signerPubkeysBuf: Buffer128[],
-    roundOnePublicBuf: Buffer128[],
-  ): [Fq, boolean] {
-    const result = this.binder.callWasmExport(
-      'schnorr_multisig_construct_signature_round_2',
-      [message, privateKey, signerRoundOnePrivateBuf, signerPubkeysBuf, roundOnePublicBuf],
-      [Fq, BoolDeserializer()],
+  acirGetSolidityVerifier(acirComposerPtr: Ptr): string {
+    const inArgs = [acirComposerPtr].map(serializeBufferable);
+    const outTypes: OutputType[] = [StringDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_get_solidity_verifier',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result as any;
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  schnorrMultisigCombineSignatures(
-    message: Uint8Array,
-    signerPubkeysBuf: Buffer128[],
-    roundOneBuf: Buffer128[],
-    roundTwoBuf: Fr[],
-  ): [Buffer32, Buffer32, boolean] {
-    const result = this.binder.callWasmExport(
-      'schnorr_multisig_combine_signatures',
-      [message, signerPubkeysBuf, roundOneBuf, roundTwoBuf],
-      [Buffer32, Buffer32, BoolDeserializer()],
+  acirHonkSolidityVerifier(proofBuf: Uint8Array, vkBuf: Uint8Array): string {
+    const inArgs = [proofBuf, vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [StringDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_honk_solidity_verifier',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result as any;
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  srsInitSrs(pointsBuf: Uint8Array, numPoints: number, g2PointBuf: Uint8Array): void {
-    const result = this.binder.callWasmExport('srs_init_srs', [pointsBuf, numPoints, g2PointBuf], []);
-    return;
+  acirSerializeProofIntoFields(acirComposerPtr: Ptr, proofBuf: Uint8Array, numInnerPublicInputs: number): Fr[] {
+    const inArgs = [acirComposerPtr, proofBuf, numInnerPublicInputs].map(serializeBufferable);
+    const outTypes: OutputType[] = [VectorDeserializer(Fr)];
+    const result = this.wasm.callWasmExport(
+      'acir_serialize_proof_into_fields',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  examplesSimpleCreateAndVerifyProof(): boolean {
-    const result = this.binder.callWasmExport('examples_simple_create_and_verify_proof', [], [BoolDeserializer()]);
-    return result[0];
+  acirSerializeVerificationKeyIntoFields(acirComposerPtr: Ptr): [Fr[], Fr] {
+    const inArgs = [acirComposerPtr].map(serializeBufferable);
+    const outTypes: OutputType[] = [VectorDeserializer(Fr), Fr];
+    const result = this.wasm.callWasmExport(
+      'acir_serialize_verification_key_into_fields',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out as any;
   }
 
-  testThreads(threads: number, iterations: number): number {
-    const result = this.binder.callWasmExport('test_threads', [threads, iterations], [NumberDeserializer()]);
-    return result[0];
+  acirProveUltraHonk(acirVec: Uint8Array, witnessVec: Uint8Array): Uint8Array {
+    const inArgs = [acirVec, witnessVec].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_prove_ultra_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  testThreadAbort(): void {
-    const result = this.binder.callWasmExport('test_thread_abort', [], []);
-    return;
+  acirProveUltraKeccakHonk(acirVec: Uint8Array, witnessVec: Uint8Array): Uint8Array {
+    const inArgs = [acirVec, witnessVec].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_prove_ultra_keccak_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  testAbort(): void {
-    const result = this.binder.callWasmExport('test_abort', [], []);
-    return;
+  acirProveUltraKeccakZkHonk(acirVec: Uint8Array, witnessVec: Uint8Array): Uint8Array {
+    const inArgs = [acirVec, witnessVec].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_prove_ultra_keccak_zk_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  commonInitSlabAllocator(circuitSize: number): void {
-    const result = this.binder.callWasmExport('common_init_slab_allocator', [circuitSize], []);
-    return;
+  acirProveUltraStarknetHonk(acirVec: Uint8Array, witnessVec: Uint8Array): Uint8Array {
+    const inArgs = [acirVec, witnessVec].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_prove_ultra_starknet_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  acirGetCircuitSizes(constraintSystemBuf: Uint8Array): [number, number, number] {
-    const result = this.binder.callWasmExport(
-      'acir_get_circuit_sizes',
-      [constraintSystemBuf],
-      [NumberDeserializer(), NumberDeserializer(), NumberDeserializer()],
+  acirProveUltraStarknetZkHonk(acirVec: Uint8Array, witnessVec: Uint8Array): Uint8Array {
+    const inArgs = [acirVec, witnessVec].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_prove_ultra_starknet_zk_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result as any;
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  acirNewAcirComposer(sizeHint: number): Ptr {
-    const result = this.binder.callWasmExport('acir_new_acir_composer', [sizeHint], [Ptr]);
-    return result[0];
+  acirVerifyUltraHonk(proofBuf: Uint8Array, vkBuf: Uint8Array): boolean {
+    const inArgs = [proofBuf, vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BoolDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_verify_ultra_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  acirDeleteAcirComposer(acirComposerPtr: Ptr): void {
-    const result = this.binder.callWasmExport('acir_delete_acir_composer', [acirComposerPtr], []);
-    return;
+  acirVerifyUltraKeccakHonk(proofBuf: Uint8Array, vkBuf: Uint8Array): boolean {
+    const inArgs = [proofBuf, vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BoolDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_verify_ultra_keccak_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  acirCreateCircuit(acirComposerPtr: Ptr, constraintSystemBuf: Uint8Array, sizeHint: number): void {
-    const result = this.binder.callWasmExport(
-      'acir_create_circuit',
-      [acirComposerPtr, constraintSystemBuf, sizeHint],
-      [],
+  acirVerifyUltraKeccakZkHonk(proofBuf: Uint8Array, vkBuf: Uint8Array): boolean {
+    const inArgs = [proofBuf, vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BoolDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_verify_ultra_keccak_zk_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return;
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  acirInitProvingKey(acirComposerPtr: Ptr, constraintSystemBuf: Uint8Array): void {
-    const result = this.binder.callWasmExport('acir_init_proving_key', [acirComposerPtr, constraintSystemBuf], []);
-    return;
+  acirVerifyUltraStarknetHonk(proofBuf: Uint8Array, vkBuf: Uint8Array): boolean {
+    const inArgs = [proofBuf, vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BoolDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_verify_ultra_starknet_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  acirCreateProof(
-    acirComposerPtr: Ptr,
-    constraintSystemBuf: Uint8Array,
-    witnessBuf: Uint8Array,
-    isRecursive: boolean,
-  ): Uint8Array {
-    const result = this.binder.callWasmExport(
-      'acir_create_proof',
-      [acirComposerPtr, constraintSystemBuf, witnessBuf, isRecursive],
-      [BufferDeserializer()],
+  acirVerifyUltraStarknetZkHonk(proofBuf: Uint8Array, vkBuf: Uint8Array): boolean {
+    const inArgs = [proofBuf, vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BoolDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_verify_ultra_starknet_zk_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result[0];
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  acirLoadVerificationKey(acirComposerPtr: Ptr, vkBuf: Uint8Array): void {
-    const result = this.binder.callWasmExport('acir_load_verification_key', [acirComposerPtr, vkBuf], []);
-    return;
+  acirWriteVkUltraHonk(acirVec: Uint8Array): Uint8Array {
+    const inArgs = [acirVec].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_write_vk_ultra_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  acirInitVerificationKey(acirComposerPtr: Ptr): void {
-    const result = this.binder.callWasmExport('acir_init_verification_key', [acirComposerPtr], []);
-    return;
+  acirWriteVkUltraKeccakHonk(acirVec: Uint8Array): Uint8Array {
+    const inArgs = [acirVec].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_write_vk_ultra_keccak_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  acirGetVerificationKey(acirComposerPtr: Ptr): Uint8Array {
-    const result = this.binder.callWasmExport('acir_get_verification_key', [acirComposerPtr], [BufferDeserializer()]);
-    return result[0];
+  acirWriteVkUltraKeccakZkHonk(acirVec: Uint8Array): Uint8Array {
+    const inArgs = [acirVec].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_write_vk_ultra_keccak_zk_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  acirVerifyProof(acirComposerPtr: Ptr, proofBuf: Uint8Array, isRecursive: boolean): boolean {
-    const result = this.binder.callWasmExport(
-      'acir_verify_proof',
-      [acirComposerPtr, proofBuf, isRecursive],
-      [BoolDeserializer()],
+  acirWriteVkUltraStarknetHonk(acirVec: Uint8Array): Uint8Array {
+    const inArgs = [acirVec].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_write_vk_ultra_starknet_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result[0];
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  acirGetSolidityVerifier(acirComposerPtr: Ptr): string {
-    const result = this.binder.callWasmExport('acir_get_solidity_verifier', [acirComposerPtr], [StringDeserializer()]);
-    return result[0];
+  acirWriteVkUltraStarknetZkHonk(acirVec: Uint8Array): Uint8Array {
+    const inArgs = [acirVec].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_write_vk_ultra_starknet_zk_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  acirSerializeProofIntoFields(acirComposerPtr: Ptr, proofBuf: Uint8Array, numInnerPublicInputs: number): Fr[] {
-    const result = this.binder.callWasmExport(
-      'acir_serialize_proof_into_fields',
-      [acirComposerPtr, proofBuf, numInnerPublicInputs],
-      [VectorDeserializer(Fr)],
+  acirProofAsFieldsUltraHonk(proofBuf: Uint8Array): Fr[] {
+    const inArgs = [proofBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [VectorDeserializer(Fr)];
+    const result = this.wasm.callWasmExport(
+      'acir_proof_as_fields_ultra_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result[0];
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 
-  acirSerializeVerificationKeyIntoFields(acirComposerPtr: Ptr): [Fr[], Fr] {
-    const result = this.binder.callWasmExport(
-      'acir_serialize_verification_key_into_fields',
-      [acirComposerPtr],
-      [VectorDeserializer(Fr), Fr],
+  acirVkAsFieldsUltraHonk(vkBuf: Uint8Array): Fr[] {
+    const inArgs = [vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [VectorDeserializer(Fr)];
+    const result = this.wasm.callWasmExport(
+      'acir_vk_as_fields_ultra_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+
+  acirVkAsFieldsMegaHonk(vkBuf: Uint8Array): Fr[] {
+    const inArgs = [vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [VectorDeserializer(Fr)];
+    const result = this.wasm.callWasmExport(
+      'acir_vk_as_fields_mega_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+
+  acirGatesAztecClient(ivcInputsBuf: Uint8Array): Uint8Array {
+    const inArgs = [ivcInputsBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_gates_aztec_client',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
     );
-    return result as any;
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
   }
 }