@fatsolutions/privacy-pools-core-starknet-sdk 0.0.43 → 0.0.45

package/src/index.ts

@@ -1,43 +1,38 @@
 /**
  * @fileoverview Privacy Pool Starknet SDK
- * 
+ *
  * This SDK provides a Starknet-specific implementation for interacting with Privacy Pool contracts.
  * It extends the core Privacy Pool SDK with Starknet-specific functionality, including:
- * 
+ *
  * - Garaga proof format conversion for efficient Groth16 verification on Starknet
  * - Contract interaction services with simulation and execution modes
  * - Event fetching and data parsing from Starknet networks
  * - Type-safe interfaces for all Privacy Pool operations
  * - Comprehensive error handling with detailed error codes
- * 
+ *
  * @example Basic Usage
  * ```typescript
  * import { PrivacyPoolStarknetSDK, StarknetDataService } from '@fatsolutions/privacy-pools-core-starknet-sdk';
- * 
+ *
  * // Initialize SDK with circuits
  * const sdk = new PrivacyPoolStarknetSDK(circuits);
- * 
+ *
  * // Create contract service
  * const contractService = sdk.createSNContractInstance(entrypointAddress, account);
- * 
+ *
  * // Deposit funds
  * const depositCall = await contractService.depositETH(amount, precommitment);
- * 
+ *
  * // Generate and execute withdrawal
  * const { withdrawalProof, calldata } = await sdk.proveWithdrawalSN(commitment, input);
  * const withdrawResult = await contractService.withdraw(withdrawal, calldata, scope, { mode: Mode.EXECUTE });
  * ```
- * 
+ *
  * @author Fat Solutions
  * @version 0.0.1
  */
 
-export {
-  generateMerkleProof,
-  getCommitment,
-  hashPrecommitment,
-  Circuits
-} from "@0xbow/privacy-pools-core-sdk";
+export { generateMerkleProof, getCommitment, hashPrecommitment, Circuits } from "@0xbow/privacy-pools-core-sdk";
 
 export type { WithdrawalProof } from "@0xbow/privacy-pools-core-sdk";
 
@@ -51,18 +46,10 @@ export { PrivacyPoolStarknetSDK } from "./sdk.js";
 export * from "./contracts/index.js";
 
 // Types and interfaces - rename conflicting exports
-export type {
-  Withdrawal as StarknetWithdrawal,
-  RelayData
-} from "./types/entrypoint.js";
+export type { Withdrawal as StarknetWithdrawal, RelayData } from "./types/entrypoint.js";
 
 // Functions from entrypoint types
-export {
-  parseRelayData,
-  parseWithdrawal,
-  serializeRelayData,
-  serializeWithdrawal
-} from "./types/entrypoint.js";
+export { parseRelayData, parseWithdrawal, serializeRelayData, serializeWithdrawal } from "./types/entrypoint.js";
 export * from "./types/conversions.js";
 export * from "./types/garaga.js";
 export * from "./types/snarkjs.js";
@@ -80,8 +67,11 @@ export * from "./utils.js";
 export * from "./constants.js";
 
 // Data service
-export {
-  StarknetDataService,
-} from "./data.service.js";
+export { StarknetDataService } from "./data.service.js";
 
 export { type StarknetAddress } from "./types/starknet.js";
+
+// Auditor
+export * from "./auditor.js";
+
+export * from "./account.service.js";

package/src/sdk.ts

@@ -1,4 +1,12 @@
-import { CircuitName, CircuitsInterface, Commitment, CommitmentProof, PrivacyPoolSDK, WithdrawalProof, WithdrawalProofInput } from "@0xbow/privacy-pools-core-sdk";
+import {
+  CircuitName,
+  CircuitsInterface,
+  Commitment,
+  CommitmentProof,
+  PrivacyPoolSDK,
+  WithdrawalProof,
+  WithdrawalProofInput,
+} from "@0xbow/privacy-pools-core-sdk";
 import { RpcProvider, Account as SNAccount } from "starknet";
 
 import { SNContractInteractionsService } from "./contracts/contracts.service.js";
@@ -7,18 +15,18 @@ import { withdrawalProofToGaragaCalldata } from "./utils.js";
 
 /**
  * Starknet-specific implementation of the Privacy Pool SDK.
- * 
+ *
  * This class extends the base PrivacyPoolSDK to provide Starknet-specific functionality,
  * including proof generation optimized for Garaga verification and contract interaction services.
- * 
+ *
  * @example
  * ```typescript
  * const circuits = new CircuitsImplementation();
  * const sdk = new PrivacyPoolStarknetSDK(circuits);
- * 
+ *
  * // Create contract service
  * const contractService = sdk.createSNContractInstance(entrypointAddress, account);
- * 
+ *
  * // Generate withdrawal proof with Starknet calldata
  * const { withdrawalProof, calldata } = await sdk.proveWithdrawalSN(commitment, input);
  * ```
@@ -28,7 +36,7 @@ export class PrivacyPoolStarknetSDK extends PrivacyPoolSDK {
 
   /**
    * Creates a new Starknet Privacy Pool SDK instance.
-   * 
+   *
    * @param circuits - Interface for circuit operations and verification key management
    */
   constructor(circuits: CircuitsInterface) {
@@ -38,68 +46,74 @@ export class PrivacyPoolStarknetSDK extends PrivacyPoolSDK {
 
   /**
    * Creates a new Starknet contract interactions service instance.
-   * 
+   *
    * @param entrypointAddress - The address of the EntryPoint contract on Starknet
    * @param providerOrAccount - Either a Starknet Account for signing transactions or RpcProvider for read-only operations
    * @returns A configured contract service instance for interacting with Privacy Pool contracts
    */
   public createSNContractInstance(
     entrypointAddress: StarknetAddress,
-    providerOrAccount: SNAccount | RpcProvider,
+    providerOrAccount: SNAccount | RpcProvider
   ): SNContractInteractionsService {
-    return new SNContractInteractionsService(
-      entrypointAddress,
-      providerOrAccount
-    );
+    return new SNContractInteractionsService(entrypointAddress, providerOrAccount);
   }
 
   /**
    * Generates a withdrawal proof optimized for Starknet/Garaga verification.
-   * 
+   *
    * This method creates a withdrawal proof and converts it to the calldata format
    * required by Garaga's Groth16 verifier on Starknet.
-   * 
+   *
    * @param commitment - The commitment to prove withdrawal for
    * @param input - The withdrawal proof input containing nullifier and other required data
    * @returns Object containing the withdrawal proof and Garaga-formatted calldata
    * @throws {Error} If proof generation fails or verification key cannot be retrieved
    */
-  async proveWithdrawalSN(commitment: Commitment, input: WithdrawalProofInput): Promise<{ withdrawalProof: WithdrawalProof, calldata: bigint[]; }> {
+  async proveWithdrawalSN(
+    commitment: Commitment,
+    input: WithdrawalProofInput
+  ): Promise<{ withdrawalProof: WithdrawalProof; calldata: bigint[] }> {
     const withdrawalProof: WithdrawalProof = await super.proveWithdrawal(commitment, input);
     const vkeyRaw = await this.circuits.getVerificationKey(CircuitName.Withdraw);
     return {
       withdrawalProof,
-      calldata: await withdrawalProofToGaragaCalldata(withdrawalProof, vkeyRaw)
+      calldata: await withdrawalProofToGaragaCalldata(withdrawalProof, vkeyRaw),
     };
   }
 
   /**
    * Generates a commitment proof optimized for Starknet/Garaga verification.
-   * 
+   *
    * This method creates a commitment proof and converts it to the calldata format
    * required by Garaga's Groth16 verifier on Starknet.
-   * 
+   *
    * @param commitment - The commitment to generate proof for
    * @returns Object containing the commitment proof and Garaga-formatted calldata
    * @throws {Error} If proof generation fails or verification key cannot be retrieved
    */
-  async proveCommitmentSN(commitment: Commitment): Promise<{ commitmentProof: CommitmentProof, calldata: bigint[]; }> {
-    const { preimage: { label, value, precommitment: { nullifier, secret } } } = commitment;
+  async proveCommitmentSN(commitment: Commitment): Promise<{ commitmentProof: CommitmentProof; calldata: bigint[] }> {
+    const {
+      preimage: {
+        label,
+        value,
+        precommitment: { nullifier, secret },
+      },
+    } = commitment;
     const commitmentProof: WithdrawalProof = await super.proveCommitment(value, label, nullifier, secret);
     const vkeyRaw = await this.circuits.getVerificationKey(CircuitName.Commitment);
     return {
       commitmentProof,
-      calldata: await withdrawalProofToGaragaCalldata(commitmentProof, vkeyRaw)
+      calldata: await withdrawalProofToGaragaCalldata(commitmentProof, vkeyRaw),
     };
   }
 
   /**
    * Converts a withdrawal proof to Garaga-formatted calldata.
-   * 
+   *
    * This utility method takes an existing withdrawal proof and converts it to the calldata format
    * required by Garaga's Groth16 verifier on Starknet. Useful when you already have a withdrawal
    * proof and need to format it for Starknet contract calls without regenerating the proof.
-   * 
+   *
    * @param withdrawalProof - The withdrawal proof to convert
    * @returns Promise resolving to Garaga-formatted calldata as an array of bigints
    * @throws {Error} If verification key cannot be retrieved or conversion fails
@@ -111,11 +125,11 @@ export class PrivacyPoolStarknetSDK extends PrivacyPoolSDK {
 
   /**
    * Converts a commitment proof to Garaga-formatted calldata.
-   * 
+   *
    * This utility method takes an existing commitment proof and converts it to the calldata format
    * required by Garaga's Groth16 verifier on Starknet. Useful when you already have a commitment
    * proof and need to format it for Starknet contract calls without regenerating the proof.
-   * 
+   *
    * @param commitmentProof - The commitment proof to convert
    * @returns Promise resolving to Garaga-formatted calldata as an array of bigints
    * @throws {Error} If verification key cannot be retrieved or conversion fails
@@ -124,5 +138,4 @@ export class PrivacyPoolStarknetSDK extends PrivacyPoolSDK {
     const vkeyRaw = await this.circuits.getVerificationKey(CircuitName.Commitment);
     return await withdrawalProofToGaragaCalldata(commitmentProof, vkeyRaw);
   }
-
 }

package/src/types/conversions.ts

@@ -4,7 +4,7 @@ import { SnarkJsGroth16Proof, SnarkJsVkey } from "./snarkjs.js";
 
 /**
  * Converts a G1 point from SnarkJS string array format to Garaga format.
- * 
+ *
  * @param s - Array containing x and y coordinates as strings
  * @returns G1 point in Garaga format with BigInt coordinates
  * @throws {SNFormatError} If the input array doesn't contain exactly 2 coordinates
@@ -22,9 +22,9 @@ export function G1StoG1G(s: string[]): G1Point$1 {
 
 /**
  * Converts a G2 point from SnarkJS nested string array format to Garaga format.
- * 
+ *
  * G2 points have coordinates in the extension field Fp2, represented as pairs of field elements.
- * 
+ *
  * @param s - Nested array containing [[x0, x1], [y0, y1]] coordinates as strings
  * @returns G2 point in Garaga format with BigInt coordinate pairs
  * @throws {SNFormatError} If the input structure is invalid or coordinates are missing
@@ -40,7 +40,9 @@ export function G2StoG2G(s: string[][]): G2Point$1 {
   const [y0, y1] = y;
 
   if (x0 === undefined || x1 === undefined || y0 === undefined || y1 === undefined) {
-    throw SNFormatError.conversion(`Invalid G2 point: incomplete coordinate pair. Input ((${x0}, ${x1}), (${y0}, ${y1}))`);
+    throw SNFormatError.conversion(
+      `Invalid G2 point: incomplete coordinate pair. Input ((${x0}, ${x1}), (${y0}, ${y1}))`
+    );
   }
 
   return {
@@ -52,10 +54,10 @@ export function G2StoG2G(s: string[][]): G2Point$1 {
 
 /**
  * Converts a SnarkJS verification key to Garaga format.
- * 
+ *
  * This function transforms the verification key structure from SnarkJS format
  * (with string coordinates) to Garaga format (with BigInt coordinates and proper typing).
- * 
+ *
  * @param vkey - SnarkJS verification key
  * @returns Verification key in Garaga format
  */
@@ -71,18 +73,15 @@ export function snarkJsKeyIntoGaraga(vkey: SnarkJsVkey): Groth16VerifyingKey {
 
 /**
  * Converts a SnarkJS Groth16 proof to Garaga format.
- * 
+ *
  * This function transforms the proof structure from SnarkJS format
  * (with string coordinates) to Garaga format (with BigInt coordinates and proper typing).
- * 
+ *
  * @param proof - SnarkJS Groth16 proof containing pi_a, pi_b, and pi_c points
  * @param publicInputs - Array of public inputs as strings
  * @returns Groth16 proof in Garaga format
  */
-export function snarkJsProofIntoGaraga(
-  proof: SnarkJsGroth16Proof,
-  publicInputs: string[]
-): Groth16Proof {
+export function snarkJsProofIntoGaraga(proof: SnarkJsGroth16Proof, publicInputs: string[]): Groth16Proof {
   return {
     a: G1StoG1G(proof.pi_a),
     b: G2StoG2G(proof.pi_b),

package/src/types/entrypoint.ts

@@ -1,37 +1,38 @@
-import { BigNumberish, cairo, CallData, num } from "starknet";
+import { BigNumberish, cairo, CallData, num, CairoOption, byteArray } from "starknet";
 
 import { EntryPointABI } from "../abis/index.js";
 import { SNFormatError } from "../errors/index.js";
 import { StarknetAddress } from "./starknet.js";
+import { AuditorData } from "../auditor.js";
 
 const RelayDataAbi = [
   {
-    "type": "interface",
+    type: "interface",
   },
   {
-    "type": "struct",
-    "name": "privacy_pools::interfaces::IEntryPoint::RelayData",
-    "members": [
+    type: "struct",
+    name: "privacy_pools::interfaces::IEntryPoint::RelayData",
+    members: [
       {
-        "name": "recipient",
-        "type": "core::starknet::contract_address::ContractAddress"
+        name: "recipient",
+        type: "core::starknet::contract_address::ContractAddress",
       },
       {
-        "name": "feeRecipient",
-        "type": "core::starknet::contract_address::ContractAddress"
+        name: "feeRecipient",
+        type: "core::starknet::contract_address::ContractAddress",
       },
       {
-        "name": "relayFeeBPS",
-        "type": "core::integer::u256"
+        name: "relayFeeBPS",
+        type: "core::integer::u256",
       },
-    ]
+    ],
   },
 ];
 
 export interface AssetConfig {
-  pool: StarknetAddress,
-  maxRelayFeeBPS: bigint,
-  minimumDepositAmount: bigint,
+  pool: StarknetAddress;
+  maxRelayFeeBPS: bigint;
+  minimumDepositAmount: bigint;
   vettingFeeBPS: bigint;
 }
 
@@ -45,7 +46,8 @@ const entrypointCd = new CallData(EntryPointABI);
  */
 export interface Withdrawal {
   /** The address of the processor handling this withdrawal */
-  processor: BigNumberish,
+  processor: BigNumberish;
+  auditorData?: AuditorData;
   /** Additional data required for processing the withdrawal */
   data: BigNumberish[];
 }
@@ -57,11 +59,11 @@ export interface Withdrawal {
  */
 export interface RelayData {
   /** The address that will receive the withdrawn funds */
-  recipient: BigNumberish,
+  recipient: BigNumberish;
   /** The address that will receive relay fees */
-  feeRecipient: BigNumberish,
+  feeRecipient: BigNumberish;
   /** The relay fee in basis points (BPS) */
-  relayFeeBPS: BigNumberish,
+  relayFeeBPS: BigNumberish;
 }
 
 /**
@@ -77,15 +79,20 @@ export function serializeRelayData(data: RelayData): `0x${string}`[] {
     num.toHex64(recipient) as `0x${string}`,
     num.toHex64(feeRecipient) as `0x${string}`,
     num.toHex64(low) as `0x${string}`,
-    num.toHex64(high) as `0x${string}`
+    num.toHex64(high) as `0x${string}`,
   ];
 }
 
 function isRelayData(data: unknown): data is RelayData {
   const _data = data as RelayData;
-  return (_data.feeRecipient !== undefined && num.isBigNumberish(_data.feeRecipient))
-    && (_data.recipient !== undefined && num.isBigNumberish(_data.recipient))
-    && (_data.relayFeeBPS !== undefined && num.isBigNumberish(_data.relayFeeBPS));
+  return (
+    _data.feeRecipient !== undefined &&
+    num.isBigNumberish(_data.feeRecipient) &&
+    _data.recipient !== undefined &&
+    num.isBigNumberish(_data.recipient) &&
+    _data.relayFeeBPS !== undefined &&
+    num.isBigNumberish(_data.relayFeeBPS)
+  );
 }
 
 /**
@@ -97,13 +104,12 @@ function isRelayData(data: unknown): data is RelayData {
  */
 export function parseRelayData(rawData: string[]): RelayData {
   if (!rawData.every(num.isBigNumberish)) {
-    throw SNFormatError.parse(`Can't parse RelayData from ${rawData}. Some values are not BigNumberish`);
+    throw SNFormatError.parse(`Can't parse RelayData from ${rawData.toString()}. Some values are not BigNumberish`);
   }
   const structName = "privacy_pools::interfaces::IEntryPoint::RelayData";
   const result = relayDataCd.decodeParameters(structName, rawData) as unknown;
-  if (isRelayData(result))
-    return result;
-  throw SNFormatError.parse(`Can't parse RelayData from ${rawData}`);
+  if (isRelayData(result)) return result;
+  throw SNFormatError.parse(`Can't parse RelayData from ${rawData.toString()}`);
 }
 
 /**
@@ -113,18 +119,44 @@ export function parseRelayData(rawData: string[]): RelayData {
  * @returns Array of string representations of the withdrawal fields
  */
 export function serializeWithdrawal(withdrawal: Withdrawal): `0x${string}`[] {
-  const { processor, data } = withdrawal;
-  return [
-    num.toHex64(processor) as `0x${string}`,
-    num.toHex64(data.length) as `0x${string}`,
-    ...data.map(x => num.toHex64(x) as `0x${string}`)
-  ];
+  const result: `0x${string}`[] = [];
+  const { processor, auditorData, data } = withdrawal;
+
+  result.push(num.toHex64(processor) as `0x${string}`);
+
+  if (auditorData === undefined) {
+    result.push(num.toHex64(1) as `0x${string}`);
+  } else {
+    result.push(num.toHex64(0) as `0x${string}`);
+    const { tag, ciphertext } = auditorData;
+    const { low, high } = cairo.uint256(tag);
+    result.push(num.toHex64(low) as `0x${string}`);
+    result.push(num.toHex64(high) as `0x${string}`);
+
+    const array = CallData.compile([byteArray.byteArrayFromString(ciphertext)]);
+    array.forEach((x) => result.push(num.toHex64(x) as `0x${string}`));
+  }
+
+  result.push(num.toHex64(data.length) as `0x${string}`);
+  data.forEach((x) => result.push(num.toHex64(x) as `0x${string}`));
+  return result;
 }
 
-function isWithdrawal(data: unknown): data is Withdrawal {
-  const _data = data as Withdrawal;
-  return (_data.processor !== undefined && num.isBigNumberish(_data.processor))
-    && (_data.data !== undefined && _data.data.every(num.isBigNumberish));
+type CairoWithdrawal = {
+  processor: BigNumberish;
+  data: BigNumberish[];
+  auditorData: CairoOption<AuditorData>;
+};
+function isWithdrawal(data: unknown): data is CairoWithdrawal {
+  const _data = data as CairoWithdrawal;
+  return (
+    _data.processor !== undefined &&
+    num.isBigNumberish(_data.processor) &&
+    _data.data !== undefined &&
+    _data.data.every(num.isBigNumberish) &&
+    ((_data.auditorData.Some?.ciphertext !== undefined && _data.auditorData.Some?.tag !== undefined) ||
+      _data.auditorData.None !== undefined)
+  );
 }
 
 /**
@@ -136,11 +168,12 @@ function isWithdrawal(data: unknown): data is Withdrawal {
  */
 export function parseWithdrawal(rawData: string[]): Withdrawal {
   if (!rawData.every(num.isBigNumberish)) {
-    throw SNFormatError.parse(`Can't parse Withdrawal from ${rawData}. Some values are not BigNumberish`);
+    throw SNFormatError.parse(`Can't parse Withdrawal from ${rawData.toString()}. Some values are not BigNumberish`);
   }
   const structName = "privacy_pools::interfaces::Structs::Withdrawal";
   const result = entrypointCd.decodeParameters(structName, rawData);
-  if (isWithdrawal(result))
-    return result;
-  throw SNFormatError.parse(`Can't parse Withdrawal from ${rawData}`);
+  if (isWithdrawal(result)) {
+    return { ...result, auditorData: result.auditorData.unwrap() };
+  }
+  throw SNFormatError.parse(`Can't parse Withdrawal from ${rawData.toString()}`);
 }

package/src/types/garaga.ts

@@ -6,12 +6,12 @@ type CurveId = 0;
  * Used in Garaga's Groth16 verification system.
  */
 export interface G1Point$1 {
-    /** The x-coordinate of the point */
-    x: bigint;
-    /** The y-coordinate of the point */
-    y: bigint;
-    /** The curve identifier (always 0 for BN254) */
-    curveId: CurveId;
+  /** The x-coordinate of the point */
+  x: bigint;
+  /** The y-coordinate of the point */
+  y: bigint;
+  /** The curve identifier (always 0 for BN254) */
+  curveId: CurveId;
 }
 
 /**
@@ -19,12 +19,12 @@ export interface G1Point$1 {
  * G2 points have coordinates in the extension field Fp2.
  */
 export interface G2Point$1 {
-    /** The x-coordinate as a pair of field elements [x0, x1] */
-    x: [bigint, bigint];
-    /** The y-coordinate as a pair of field elements [y0, y1] */
-    y: [bigint, bigint];
-    /** The curve identifier (always 0 for BN254) */
-    curveId: CurveId;
+  /** The x-coordinate as a pair of field elements [x0, x1] */
+  x: [bigint, bigint];
+  /** The y-coordinate as a pair of field elements [y0, y1] */
+  y: [bigint, bigint];
+  /** The curve identifier (always 0 for BN254) */
+  curveId: CurveId;
 }
 
 /**
@@ -32,16 +32,16 @@ export interface G2Point$1 {
  * Contains the proof points and public inputs.
  */
 export interface Groth16Proof {
-    /** The A point of the Groth16 proof (G1 point) */
-    a: G1Point$1;
-    /** The B point of the Groth16 proof (G2 point) */
-    b: G2Point$1;
-    /** The C point of the Groth16 proof (G1 point) */
-    c: G1Point$1;
-    /** The public inputs to the circuit */
-    publicInputs: bigint[];
-    /** Optional curve identifier */
-    curveId?: CurveId;
+  /** The A point of the Groth16 proof (G1 point) */
+  a: G1Point$1;
+  /** The B point of the Groth16 proof (G2 point) */
+  b: G2Point$1;
+  /** The C point of the Groth16 proof (G1 point) */
+  c: G1Point$1;
+  /** The public inputs to the circuit */
+  publicInputs: bigint[];
+  /** Optional curve identifier */
+  curveId?: CurveId;
 }
 
 /**
@@ -49,14 +49,14 @@ export interface Groth16Proof {
  * Contains the cryptographic parameters needed for proof verification.
  */
 export interface Groth16VerifyingKey {
-    /** The alpha parameter (G1 point) */
-    alpha: G1Point$1;
-    /** The beta parameter (G2 point) */
-    beta: G2Point$1;
-    /** The gamma parameter (G2 point) */
-    gamma: G2Point$1;
-    /** The delta parameter (G2 point) */
-    delta: G2Point$1;
-    /** Array of IC parameters (G1 points) for public inputs */
-    ic: G1Point$1[];
+  /** The alpha parameter (G1 point) */
+  alpha: G1Point$1;
+  /** The beta parameter (G2 point) */
+  beta: G2Point$1;
+  /** The gamma parameter (G2 point) */
+  gamma: G2Point$1;
+  /** The delta parameter (G2 point) */
+  delta: G2Point$1;
+  /** Array of IC parameters (G1 points) for public inputs */
+  ic: G1Point$1[];
 }

package/src/types/index.ts

@@ -1,4 +1,4 @@
 export * from "./conversions.js";
 export * from "./entrypoint.js";
 export * from "./garaga.js";
-export * from "./snarkjs.js";
+export * from "./snarkjs.js";

package/src/types/snarkjs.ts

@@ -3,24 +3,12 @@ import { type Groth16Proof } from "snarkjs";
 export type SnarkJsGroth16Proof = Groth16Proof;
 
 export interface SnarkJsVkey {
-  protocol: 'groth16',
-  curve: 'bn128',
-  nPublic: number,
-  vk_alpha_1: [string, string, '1'],
-  vk_beta_2: [
-    [string, string],
-    [string, string,],
-    ['1', '0']
-  ],
-  vk_gamma_2: [
-    [string, string],
-    [string, string],
-    ['1', '0']
-  ],
-  vk_delta_2: [
-    [string, string],
-    [string, string],
-    ['1', '0']
-  ],
-  IC: [string, string, '1'][];
+  protocol: "groth16";
+  curve: "bn128";
+  nPublic: number;
+  vk_alpha_1: [string, string, "1"];
+  vk_beta_2: [[string, string], [string, string], ["1", "0"]];
+  vk_gamma_2: [[string, string], [string, string], ["1", "0"]];
+  vk_delta_2: [[string, string], [string, string], ["1", "0"]];
+  IC: [string, string, "1"][];
 }