@aztec/bb.js 3.0.0-devnet.2 → 3.0.0-devnet.2-patch.1

package/src/cbind/generated/api_types.ts

@@ -2,9 +2,12 @@
 
 
 // Type aliases
+export type Field2 = [Uint8Array, Uint8Array];
 export type Fq = Uint8Array;
 export type Fr = Uint8Array;
+export type Secp256k1Fq = Uint8Array;
 export type Secp256k1Fr = Uint8Array;
+export type Secp256r1Fq = Uint8Array;
 export type Secp256r1Fr = Uint8Array;
 export type Uint256T = Uint8Array;
 
@@ -53,16 +56,6 @@ interface MsgpackAesEncryptResponse {
   ciphertext: Uint8Array;
 }
 
-export interface AffineElement {
-  x: Fr;
-  y: Fr;
-}
-
-interface MsgpackAffineElement {
-  x: Uint8Array;
-  y: Uint8Array;
-}
-
 export interface Blake2s {
   data: Uint8Array;
 }
@@ -95,324 +88,420 @@ interface MsgpackBlake2sToFieldResponse {
   field: Uint8Array;
 }
 
-export interface Bn254FrSqrt {
-  input: Fr;
+export interface Bn254FqSqrt {
+  input: Fq;
 }
 
-interface MsgpackBn254FrSqrt {
+interface MsgpackBn254FqSqrt {
   input: Uint8Array;
 }
 
-export interface Bn254FrSqrtResponse {
+export interface Bn254FqSqrtResponse {
   isSquareRoot: boolean;
-  value: Fr;
+  value: Fq;
 }
 
-interface MsgpackBn254FrSqrtResponse {
+interface MsgpackBn254FqSqrtResponse {
   is_square_root: boolean;
   value: Uint8Array;
 }
 
-export interface CircuitComputeVk {
-  circuit: CircuitInputNoVK;
-  settings: ProofSystemSettings;
+export interface Bn254FrSqrt {
+  input: Fr;
 }
 
-interface MsgpackCircuitComputeVk {
-  circuit: MsgpackCircuitInputNoVK;
-  settings: MsgpackProofSystemSettings;
+interface MsgpackBn254FrSqrt {
+  input: Uint8Array;
 }
 
-export interface CircuitComputeVkResponse {
-  bytes: Uint8Array;
-  fields: Uint256T[];
-  hash: Uint8Array;
+export interface Bn254FrSqrtResponse {
+  isSquareRoot: boolean;
+  value: Fr;
 }
 
-interface MsgpackCircuitComputeVkResponse {
-  bytes: Uint8Array;
-  fields: Uint8Array[];
-  hash: Uint8Array;
+interface MsgpackBn254FrSqrtResponse {
+  is_square_root: boolean;
+  value: Uint8Array;
 }
 
-export interface CircuitInfoResponse {
-  numGates: number;
-  numGatesDyadic: number;
-  numAcirOpcodes: number;
-  gatesPerOpcode: number[];
+export interface Bn254G1FromCompressed {
+  compressed: Uint8Array;
 }
 
-interface MsgpackCircuitInfoResponse {
-  num_gates: number;
-  num_gates_dyadic: number;
-  num_acir_opcodes: number;
-  gates_per_opcode: number[];
+interface MsgpackBn254G1FromCompressed {
+  compressed: Uint8Array;
 }
 
-export interface CircuitInput {
-  name: string;
-  bytecode: Uint8Array;
-  verificationKey: Uint8Array;
+export interface Bn254G1FromCompressedResponse {
+  point: Bn254G1Point;
 }
 
-interface MsgpackCircuitInput {
-  name: string;
-  bytecode: Uint8Array;
-  verification_key: Uint8Array;
+interface MsgpackBn254G1FromCompressedResponse {
+  point: MsgpackBn254G1Point;
 }
 
-export interface CircuitInputNoVK {
-  name: string;
-  bytecode: Uint8Array;
+export interface Bn254G1IsOnCurve {
+  point: Bn254G1Point;
 }
 
-interface MsgpackCircuitInputNoVK {
-  name: string;
-  bytecode: Uint8Array;
+interface MsgpackBn254G1IsOnCurve {
+  point: MsgpackBn254G1Point;
 }
 
-export interface CircuitProve {
-  circuit: CircuitInput;
-  witness: Uint8Array;
-  settings: ProofSystemSettings;
+export interface Bn254G1IsOnCurveResponse {
+  isOnCurve: boolean;
 }
 
-interface MsgpackCircuitProve {
-  circuit: MsgpackCircuitInput;
-  witness: Uint8Array;
-  settings: MsgpackProofSystemSettings;
+interface MsgpackBn254G1IsOnCurveResponse {
+  is_on_curve: boolean;
 }
 
-export interface CircuitProveResponse {
-  publicInputs: Uint256T[];
-  proof: Uint256T[];
-  vk: CircuitComputeVkResponse;
+export interface Bn254G1Mul {
+  point: Bn254G1Point;
+  scalar: Fr;
 }
 
-interface MsgpackCircuitProveResponse {
-  public_inputs: Uint8Array[];
-  proof: Uint8Array[];
-  vk: MsgpackCircuitComputeVkResponse;
+interface MsgpackBn254G1Mul {
+  point: MsgpackBn254G1Point;
+  scalar: Uint8Array;
 }
 
-export interface CircuitStats {
-  circuit: CircuitInput;
-  includeGatesPerOpcode: boolean;
-  settings: ProofSystemSettings;
+export interface Bn254G1MulResponse {
+  point: Bn254G1Point;
 }
 
-interface MsgpackCircuitStats {
-  circuit: MsgpackCircuitInput;
-  include_gates_per_opcode: boolean;
-  settings: MsgpackProofSystemSettings;
+interface MsgpackBn254G1MulResponse {
+  point: MsgpackBn254G1Point;
 }
 
-export interface CircuitVerify {
-  verificationKey: Uint8Array;
-  publicInputs: Uint256T[];
-  proof: Uint256T[];
-  settings: ProofSystemSettings;
+export interface Bn254G1Point {
+  x: Fq;
+  y: Fq;
 }
 
-interface MsgpackCircuitVerify {
-  verification_key: Uint8Array;
-  public_inputs: Uint8Array[];
-  proof: Uint8Array[];
-  settings: MsgpackProofSystemSettings;
+interface MsgpackBn254G1Point {
+  x: Uint8Array;
+  y: Uint8Array;
 }
 
-export interface CircuitVerifyResponse {
-  verified: boolean;
+export interface Bn254G2Mul {
+  point: Bn254G2Point;
+  scalar: Fr;
 }
 
-interface MsgpackCircuitVerifyResponse {
-  verified: boolean;
+interface MsgpackBn254G2Mul {
+  point: MsgpackBn254G2Point;
+  scalar: Uint8Array;
 }
 
-export interface CircuitWriteSolidityVerifier {
-  verificationKey: Uint8Array;
-  settings: ProofSystemSettings;
+export interface Bn254G2MulResponse {
+  point: Bn254G2Point;
 }
 
-interface MsgpackCircuitWriteSolidityVerifier {
-  verification_key: Uint8Array;
-  settings: MsgpackProofSystemSettings;
+interface MsgpackBn254G2MulResponse {
+  point: MsgpackBn254G2Point;
 }
 
-export interface CircuitWriteSolidityVerifierResponse {
-  solidityCode: string;
+export interface Bn254G2Point {
+  x: Field2;
+  y: Field2;
 }
 
-interface MsgpackCircuitWriteSolidityVerifierResponse {
-  solidity_code: string;
+interface MsgpackBn254G2Point {
+  x: [Uint8Array, Uint8Array];
+  y: [Uint8Array, Uint8Array];
 }
 
-export interface ClientIvcAccumulate {
+export interface ChonkAccumulate {
   witness: Uint8Array;
 }
 
-interface MsgpackClientIvcAccumulate {
+interface MsgpackChonkAccumulate {
   witness: Uint8Array;
 }
 
-export interface ClientIvcAccumulateResponse {
+export interface ChonkAccumulateResponse {
 }
 
-interface MsgpackClientIvcAccumulateResponse {
+interface MsgpackChonkAccumulateResponse {
 }
 
-export interface ClientIvcCheckPrecomputedVk {
+export interface ChonkCheckPrecomputedVk {
   circuit: CircuitInput;
 }
 
-interface MsgpackClientIvcCheckPrecomputedVk {
+interface MsgpackChonkCheckPrecomputedVk {
   circuit: MsgpackCircuitInput;
 }
 
-export interface ClientIvcCheckPrecomputedVkResponse {
+export interface ChonkCheckPrecomputedVkResponse {
   valid: boolean;
   actualVk: Uint8Array;
 }
 
-interface MsgpackClientIvcCheckPrecomputedVkResponse {
+interface MsgpackChonkCheckPrecomputedVkResponse {
   valid: boolean;
   actual_vk: Uint8Array;
 }
 
-export interface ClientIvcComputeIvcVk {
+export interface ChonkComputeIvcVk {
   circuit: CircuitInputNoVK;
 }
 
-interface MsgpackClientIvcComputeIvcVk {
+interface MsgpackChonkComputeIvcVk {
   circuit: MsgpackCircuitInputNoVK;
 }
 
-export interface ClientIvcComputeIvcVkResponse {
+export interface ChonkComputeIvcVkResponse {
   bytes: Uint8Array;
 }
 
-interface MsgpackClientIvcComputeIvcVkResponse {
+interface MsgpackChonkComputeIvcVkResponse {
   bytes: Uint8Array;
 }
 
-export interface ClientIvcComputeStandaloneVk {
+export interface ChonkComputeStandaloneVk {
   circuit: CircuitInputNoVK;
 }
 
-interface MsgpackClientIvcComputeStandaloneVk {
+interface MsgpackChonkComputeStandaloneVk {
   circuit: MsgpackCircuitInputNoVK;
 }
 
-export interface ClientIvcComputeStandaloneVkResponse {
+export interface ChonkComputeStandaloneVkResponse {
   bytes: Uint8Array;
   fields: Fr[];
 }
 
-interface MsgpackClientIvcComputeStandaloneVkResponse {
+interface MsgpackChonkComputeStandaloneVkResponse {
   bytes: Uint8Array;
   fields: Uint8Array[];
 }
 
-export interface ClientIvcLoad {
+export interface ChonkLoad {
   circuit: CircuitInput;
 }
 
-interface MsgpackClientIvcLoad {
+interface MsgpackChonkLoad {
   circuit: MsgpackCircuitInput;
 }
 
-export interface ClientIvcLoadResponse {
+export interface ChonkLoadResponse {
 }
 
-interface MsgpackClientIvcLoadResponse {
+interface MsgpackChonkLoadResponse {
 }
 
-export interface ClientIVCProof {
+export interface ChonkProof {
   megaProof: Fr[];
   goblinProof: GoblinProof;
 }
 
-interface MsgpackClientIVCProof {
+interface MsgpackChonkProof {
   mega_proof: Uint8Array[];
   goblin_proof: MsgpackGoblinProof;
 }
 
-export interface ClientIvcProve {
+export interface ChonkProve {
 }
 
-interface MsgpackClientIvcProve {
+interface MsgpackChonkProve {
 }
 
-export interface ClientIvcProveResponse {
-  proof: ClientIVCProof;
+export interface ChonkProveResponse {
+  proof: ChonkProof;
 }
 
-interface MsgpackClientIvcProveResponse {
-  proof: MsgpackClientIVCProof;
+interface MsgpackChonkProveResponse {
+  proof: MsgpackChonkProof;
 }
 
-export interface ClientIvcStart {
+export interface ChonkStart {
   numCircuits: number;
 }
 
-interface MsgpackClientIvcStart {
+interface MsgpackChonkStart {
   num_circuits: number;
 }
 
-export interface ClientIvcStartResponse {
+export interface ChonkStartResponse {
 }
 
-interface MsgpackClientIvcStartResponse {
+interface MsgpackChonkStartResponse {
 }
 
-export interface ClientIvcStats {
+export interface ChonkStats {
   circuit: CircuitInputNoVK;
   includeGatesPerOpcode: boolean;
 }
 
-interface MsgpackClientIvcStats {
+interface MsgpackChonkStats {
   circuit: MsgpackCircuitInputNoVK;
   include_gates_per_opcode: boolean;
 }
 
-export interface ClientIvcStatsResponse {
+export interface ChonkStatsResponse {
   acirOpcodes: number;
   circuitSize: number;
   gatesPerOpcode: number[];
 }
 
-interface MsgpackClientIvcStatsResponse {
+interface MsgpackChonkStatsResponse {
   acir_opcodes: number;
   circuit_size: number;
   gates_per_opcode: number[];
 }
 
-export interface ClientIvcVerify {
-  proof: ClientIVCProof;
+export interface ChonkVerify {
+  proof: ChonkProof;
   vk: Uint8Array;
 }
 
-interface MsgpackClientIvcVerify {
-  proof: MsgpackClientIVCProof;
+interface MsgpackChonkVerify {
+  proof: MsgpackChonkProof;
   vk: Uint8Array;
 }
 
-export interface ClientIvcVerifyResponse {
+export interface ChonkVerifyResponse {
   valid: boolean;
 }
 
-interface MsgpackClientIvcVerifyResponse {
+interface MsgpackChonkVerifyResponse {
   valid: boolean;
 }
 
-export interface ECCVMProof {
-  preIpaProof: Fr[];
-  ipaProof: Fr[];
+export interface CircuitComputeVk {
+  circuit: CircuitInputNoVK;
+  settings: ProofSystemSettings;
 }
 
-interface MsgpackECCVMProof {
-  pre_ipa_proof: Uint8Array[];
-  ipa_proof: Uint8Array[];
+interface MsgpackCircuitComputeVk {
+  circuit: MsgpackCircuitInputNoVK;
+  settings: MsgpackProofSystemSettings;
+}
+
+export interface CircuitComputeVkResponse {
+  bytes: Uint8Array;
+  fields: Uint256T[];
+  hash: Uint8Array;
+}
+
+interface MsgpackCircuitComputeVkResponse {
+  bytes: Uint8Array;
+  fields: Uint8Array[];
+  hash: Uint8Array;
+}
+
+export interface CircuitInfoResponse {
+  numGates: number;
+  numGatesDyadic: number;
+  numAcirOpcodes: number;
+  gatesPerOpcode: number[];
+}
+
+interface MsgpackCircuitInfoResponse {
+  num_gates: number;
+  num_gates_dyadic: number;
+  num_acir_opcodes: number;
+  gates_per_opcode: number[];
+}
+
+export interface CircuitInput {
+  name: string;
+  bytecode: Uint8Array;
+  verificationKey: Uint8Array;
+}
+
+interface MsgpackCircuitInput {
+  name: string;
+  bytecode: Uint8Array;
+  verification_key: Uint8Array;
+}
+
+export interface CircuitInputNoVK {
+  name: string;
+  bytecode: Uint8Array;
+}
+
+interface MsgpackCircuitInputNoVK {
+  name: string;
+  bytecode: Uint8Array;
+}
+
+export interface CircuitProve {
+  circuit: CircuitInput;
+  witness: Uint8Array;
+  settings: ProofSystemSettings;
+}
+
+interface MsgpackCircuitProve {
+  circuit: MsgpackCircuitInput;
+  witness: Uint8Array;
+  settings: MsgpackProofSystemSettings;
+}
+
+export interface CircuitProveResponse {
+  publicInputs: Uint256T[];
+  proof: Uint256T[];
+  vk: CircuitComputeVkResponse;
+}
+
+interface MsgpackCircuitProveResponse {
+  public_inputs: Uint8Array[];
+  proof: Uint8Array[];
+  vk: MsgpackCircuitComputeVkResponse;
+}
+
+export interface CircuitStats {
+  circuit: CircuitInput;
+  includeGatesPerOpcode: boolean;
+  settings: ProofSystemSettings;
+}
+
+interface MsgpackCircuitStats {
+  circuit: MsgpackCircuitInput;
+  include_gates_per_opcode: boolean;
+  settings: MsgpackProofSystemSettings;
+}
+
+export interface CircuitVerify {
+  verificationKey: Uint8Array;
+  publicInputs: Uint256T[];
+  proof: Uint256T[];
+  settings: ProofSystemSettings;
+}
+
+interface MsgpackCircuitVerify {
+  verification_key: Uint8Array;
+  public_inputs: Uint8Array[];
+  proof: Uint8Array[];
+  settings: MsgpackProofSystemSettings;
+}
+
+export interface CircuitVerifyResponse {
+  verified: boolean;
+}
+
+interface MsgpackCircuitVerifyResponse {
+  verified: boolean;
+}
+
+export interface CircuitWriteSolidityVerifier {
+  verificationKey: Uint8Array;
+  settings: ProofSystemSettings;
+}
+
+interface MsgpackCircuitWriteSolidityVerifier {
+  verification_key: Uint8Array;
+  settings: MsgpackProofSystemSettings;
+}
+
+export interface CircuitWriteSolidityVerifierResponse {
+  solidityCode: string;
+}
+
+interface MsgpackCircuitWriteSolidityVerifierResponse {
+  solidity_code: string;
 }
 
 export interface EcdsaSecp256k1ComputePublicKey {
@@ -424,11 +513,11 @@ interface MsgpackEcdsaSecp256k1ComputePublicKey {
 }
 
 export interface EcdsaSecp256k1ComputePublicKeyResponse {
-  publicKey: AffineElement;
+  publicKey: Secp256k1Point;
 }
 
 interface MsgpackEcdsaSecp256k1ComputePublicKeyResponse {
-  public_key: MsgpackAffineElement;
+  public_key: MsgpackSecp256k1Point;
 }
 
 export interface EcdsaSecp256k1ConstructSignature {
@@ -468,16 +557,16 @@ interface MsgpackEcdsaSecp256k1RecoverPublicKey {
 }
 
 export interface EcdsaSecp256k1RecoverPublicKeyResponse {
-  publicKey: AffineElement;
+  publicKey: Secp256k1Point;
 }
 
 interface MsgpackEcdsaSecp256k1RecoverPublicKeyResponse {
-  public_key: MsgpackAffineElement;
+  public_key: MsgpackSecp256k1Point;
 }
 
 export interface EcdsaSecp256k1VerifySignature {
   message: Uint8Array;
-  publicKey: AffineElement;
+  publicKey: Secp256k1Point;
   r: Uint8Array;
   s: Uint8Array;
   v: number;
@@ -485,7 +574,7 @@ export interface EcdsaSecp256k1VerifySignature {
 
 interface MsgpackEcdsaSecp256k1VerifySignature {
   message: Uint8Array;
-  public_key: MsgpackAffineElement;
+  public_key: MsgpackSecp256k1Point;
   r: Uint8Array;
   s: Uint8Array;
   v: number;
@@ -508,11 +597,11 @@ interface MsgpackEcdsaSecp256r1ComputePublicKey {
 }
 
 export interface EcdsaSecp256r1ComputePublicKeyResponse {
-  publicKey: AffineElement;
+  publicKey: Secp256r1Point;
 }
 
 interface MsgpackEcdsaSecp256r1ComputePublicKeyResponse {
-  public_key: MsgpackAffineElement;
+  public_key: MsgpackSecp256r1Point;
 }
 
 export interface EcdsaSecp256r1ConstructSignature {
@@ -552,16 +641,16 @@ interface MsgpackEcdsaSecp256r1RecoverPublicKey {
 }
 
 export interface EcdsaSecp256r1RecoverPublicKeyResponse {
-  publicKey: AffineElement;
+  publicKey: Secp256r1Point;
 }
 
 interface MsgpackEcdsaSecp256r1RecoverPublicKeyResponse {
-  public_key: MsgpackAffineElement;
+  public_key: MsgpackSecp256r1Point;
 }
 
 export interface EcdsaSecp256r1VerifySignature {
   message: Uint8Array;
-  publicKey: AffineElement;
+  publicKey: Secp256r1Point;
   r: Uint8Array;
   s: Uint8Array;
   v: number;
@@ -569,7 +658,7 @@ export interface EcdsaSecp256r1VerifySignature {
 
 interface MsgpackEcdsaSecp256r1VerifySignature {
   message: Uint8Array;
-  public_key: MsgpackAffineElement;
+  public_key: MsgpackSecp256r1Point;
   r: Uint8Array;
   s: Uint8Array;
   v: number;
@@ -583,52 +672,62 @@ interface MsgpackEcdsaSecp256r1VerifySignatureResponse {
   verified: boolean;
 }
 
+export interface ErrorResponse {
+  message: string;
+}
+
+interface MsgpackErrorResponse {
+  message: string;
+}
+
 export interface GoblinProof {
   mergeProof: Fr[];
-  eccvmProof: ECCVMProof;
+  eccvmProof: Fr[];
+  ipaProof: Fr[];
   translatorProof: Fr[];
 }
 
 interface MsgpackGoblinProof {
   merge_proof: Uint8Array[];
-  eccvm_proof: MsgpackECCVMProof;
+  eccvm_proof: Uint8Array[];
+  ipa_proof: Uint8Array[];
   translator_proof: Uint8Array[];
 }
 
 export interface GrumpkinAdd {
-  pointA: AffineElement;
-  pointB: AffineElement;
+  pointA: GrumpkinPoint;
+  pointB: GrumpkinPoint;
 }
 
 interface MsgpackGrumpkinAdd {
-  point_a: MsgpackAffineElement;
-  point_b: MsgpackAffineElement;
+  point_a: MsgpackGrumpkinPoint;
+  point_b: MsgpackGrumpkinPoint;
 }
 
 export interface GrumpkinAddResponse {
-  point: AffineElement;
+  point: GrumpkinPoint;
 }
 
 interface MsgpackGrumpkinAddResponse {
-  point: MsgpackAffineElement;
+  point: MsgpackGrumpkinPoint;
 }
 
 export interface GrumpkinBatchMul {
-  points: AffineElement[];
+  points: GrumpkinPoint[];
   scalar: Fq;
 }
 
 interface MsgpackGrumpkinBatchMul {
-  points: MsgpackAffineElement[];
+  points: MsgpackGrumpkinPoint[];
   scalar: Uint8Array;
 }
 
 export interface GrumpkinBatchMulResponse {
-  points: AffineElement[];
+  points: GrumpkinPoint[];
 }
 
 interface MsgpackGrumpkinBatchMulResponse {
-  points: MsgpackAffineElement[];
+  points: MsgpackGrumpkinPoint[];
 }
 
 export interface GrumpkinGetRandomFr {
@@ -648,25 +747,35 @@ interface MsgpackGrumpkinGetRandomFrResponse {
 }
 
 export interface GrumpkinMul {
-  point: AffineElement;
+  point: GrumpkinPoint;
   scalar: Fq;
 }
 
 interface MsgpackGrumpkinMul {
-  point: MsgpackAffineElement;
+  point: MsgpackGrumpkinPoint;
   scalar: Uint8Array;
 }
 
 export interface GrumpkinMulResponse {
-  point: AffineElement;
+  point: GrumpkinPoint;
 }
 
 interface MsgpackGrumpkinMulResponse {
-  point: MsgpackAffineElement;
+  point: MsgpackGrumpkinPoint;
 }
 
-export interface GrumpkinReduce512 {
-  input: Uint8Array;
+export interface GrumpkinPoint {
+  x: Fr;
+  y: Fr;
+}
+
+interface MsgpackGrumpkinPoint {
+  x: Uint8Array;
+  y: Uint8Array;
+}
+
+export interface GrumpkinReduce512 {
+  input: Uint8Array;
 }
 
 interface MsgpackGrumpkinReduce512 {
@@ -708,11 +817,11 @@ interface MsgpackPedersenCommit {
 }
 
 export interface PedersenCommitResponse {
-  point: AffineElement;
+  point: GrumpkinPoint;
 }
 
 interface MsgpackPedersenCommitResponse {
-  point: MsgpackAffineElement;
+  point: MsgpackGrumpkinPoint;
 }
 
 export interface PedersenHash {
@@ -822,11 +931,11 @@ interface MsgpackSchnorrComputePublicKey {
 }
 
 export interface SchnorrComputePublicKeyResponse {
-  publicKey: AffineElement;
+  publicKey: GrumpkinPoint;
 }
 
 interface MsgpackSchnorrComputePublicKeyResponse {
-  public_key: MsgpackAffineElement;
+  public_key: MsgpackGrumpkinPoint;
 }
 
 export interface SchnorrConstructSignature {
@@ -851,14 +960,14 @@ interface MsgpackSchnorrConstructSignatureResponse {
 
 export interface SchnorrVerifySignature {
   message: Uint8Array;
-  publicKey: AffineElement;
+  publicKey: GrumpkinPoint;
   s: Uint8Array;
   e: Uint8Array;
 }
 
 interface MsgpackSchnorrVerifySignature {
   message: Uint8Array;
-  public_key: MsgpackAffineElement;
+  public_key: MsgpackGrumpkinPoint;
   s: Uint8Array;
   e: Uint8Array;
 }
@@ -888,21 +997,31 @@ interface MsgpackSecp256k1GetRandomFrResponse {
 }
 
 export interface Secp256k1Mul {
-  point: AffineElement;
+  point: Secp256k1Point;
   scalar: Secp256k1Fr;
 }
 
 interface MsgpackSecp256k1Mul {
-  point: MsgpackAffineElement;
+  point: MsgpackSecp256k1Point;
   scalar: Uint8Array;
 }
 
 export interface Secp256k1MulResponse {
-  point: AffineElement;
+  point: Secp256k1Point;
 }
 
 interface MsgpackSecp256k1MulResponse {
-  point: MsgpackAffineElement;
+  point: MsgpackSecp256k1Point;
+}
+
+export interface Secp256k1Point {
+  x: Secp256k1Fq;
+  y: Secp256k1Fq;
+}
+
+interface MsgpackSecp256k1Point {
+  x: Uint8Array;
+  y: Uint8Array;
 }
 
 export interface Secp256k1Reduce512 {
@@ -921,6 +1040,16 @@ interface MsgpackSecp256k1Reduce512Response {
   value: Uint8Array;
 }
 
+export interface Secp256r1Point {
+  x: Secp256r1Fq;
+  y: Secp256r1Fq;
+}
+
+interface MsgpackSecp256r1Point {
+  x: Uint8Array;
+  y: Uint8Array;
+}
+
 export interface Shutdown {
 }
 
@@ -1032,16 +1161,6 @@ interface MsgpackAesEncryptResponse {
   ciphertext: Uint8Array;
 }
 
-export interface AffineElement {
-  x: Fr;
-  y: Fr;
-}
-
-interface MsgpackAffineElement {
-  x: Uint8Array;
-  y: Uint8Array;
-}
-
 export interface Blake2s {
   data: Uint8Array;
 }
@@ -1074,407 +1193,503 @@ interface MsgpackBlake2sToFieldResponse {
   field: Uint8Array;
 }
 
-export interface Bn254FrSqrt {
-  input: Fr;
+export interface Bn254FqSqrt {
+  input: Fq;
 }
 
-interface MsgpackBn254FrSqrt {
+interface MsgpackBn254FqSqrt {
   input: Uint8Array;
 }
 
-export interface Bn254FrSqrtResponse {
+export interface Bn254FqSqrtResponse {
   isSquareRoot: boolean;
-  value: Fr;
+  value: Fq;
 }
 
-interface MsgpackBn254FrSqrtResponse {
+interface MsgpackBn254FqSqrtResponse {
   is_square_root: boolean;
   value: Uint8Array;
 }
 
-export interface CircuitComputeVk {
-  circuit: CircuitInputNoVK;
-  settings: ProofSystemSettings;
+export interface Bn254FrSqrt {
+  input: Fr;
 }
 
-interface MsgpackCircuitComputeVk {
-  circuit: MsgpackCircuitInputNoVK;
-  settings: MsgpackProofSystemSettings;
+interface MsgpackBn254FrSqrt {
+  input: Uint8Array;
 }
 
-export interface CircuitComputeVkResponse {
-  bytes: Uint8Array;
-  fields: Uint256T[];
-  hash: Uint8Array;
+export interface Bn254FrSqrtResponse {
+  isSquareRoot: boolean;
+  value: Fr;
 }
 
-interface MsgpackCircuitComputeVkResponse {
-  bytes: Uint8Array;
-  fields: Uint8Array[];
-  hash: Uint8Array;
+interface MsgpackBn254FrSqrtResponse {
+  is_square_root: boolean;
+  value: Uint8Array;
 }
 
-export interface CircuitInfoResponse {
-  numGates: number;
-  numGatesDyadic: number;
-  numAcirOpcodes: number;
-  gatesPerOpcode: number[];
+export interface Bn254G1FromCompressed {
+  compressed: Uint8Array;
 }
 
-interface MsgpackCircuitInfoResponse {
-  num_gates: number;
-  num_gates_dyadic: number;
-  num_acir_opcodes: number;
-  gates_per_opcode: number[];
+interface MsgpackBn254G1FromCompressed {
+  compressed: Uint8Array;
 }
 
-export interface CircuitInput {
-  name: string;
-  bytecode: Uint8Array;
-  verificationKey: Uint8Array;
+export interface Bn254G1FromCompressedResponse {
+  point: Bn254G1Point;
 }
 
-interface MsgpackCircuitInput {
-  name: string;
-  bytecode: Uint8Array;
-  verification_key: Uint8Array;
+interface MsgpackBn254G1FromCompressedResponse {
+  point: MsgpackBn254G1Point;
 }
 
-export interface CircuitInputNoVK {
-  name: string;
-  bytecode: Uint8Array;
+export interface Bn254G1IsOnCurve {
+  point: Bn254G1Point;
 }
 
-interface MsgpackCircuitInputNoVK {
-  name: string;
-  bytecode: Uint8Array;
+interface MsgpackBn254G1IsOnCurve {
+  point: MsgpackBn254G1Point;
 }
 
-export interface CircuitProve {
-  circuit: CircuitInput;
-  witness: Uint8Array;
-  settings: ProofSystemSettings;
+export interface Bn254G1IsOnCurveResponse {
+  isOnCurve: boolean;
 }
 
-interface MsgpackCircuitProve {
-  circuit: MsgpackCircuitInput;
-  witness: Uint8Array;
-  settings: MsgpackProofSystemSettings;
+interface MsgpackBn254G1IsOnCurveResponse {
+  is_on_curve: boolean;
 }
 
-export interface CircuitProveResponse {
-  publicInputs: Uint256T[];
-  proof: Uint256T[];
-  vk: CircuitComputeVkResponse;
+export interface Bn254G1Mul {
+  point: Bn254G1Point;
+  scalar: Fr;
 }
 
-interface MsgpackCircuitProveResponse {
-  public_inputs: Uint8Array[];
-  proof: Uint8Array[];
-  vk: MsgpackCircuitComputeVkResponse;
+interface MsgpackBn254G1Mul {
+  point: MsgpackBn254G1Point;
+  scalar: Uint8Array;
 }
 
-export interface CircuitStats {
-  circuit: CircuitInput;
-  includeGatesPerOpcode: boolean;
-  settings: ProofSystemSettings;
+export interface Bn254G1MulResponse {
+  point: Bn254G1Point;
 }
 
-interface MsgpackCircuitStats {
-  circuit: MsgpackCircuitInput;
-  include_gates_per_opcode: boolean;
-  settings: MsgpackProofSystemSettings;
+interface MsgpackBn254G1MulResponse {
+  point: MsgpackBn254G1Point;
 }
 
-export interface CircuitVerify {
-  verificationKey: Uint8Array;
-  publicInputs: Uint256T[];
-  proof: Uint256T[];
-  settings: ProofSystemSettings;
+export interface Bn254G1Point {
+  x: Fq;
+  y: Fq;
 }
 
-interface MsgpackCircuitVerify {
-  verification_key: Uint8Array;
-  public_inputs: Uint8Array[];
-  proof: Uint8Array[];
-  settings: MsgpackProofSystemSettings;
+interface MsgpackBn254G1Point {
+  x: Uint8Array;
+  y: Uint8Array;
 }
 
-export interface CircuitVerifyResponse {
-  verified: boolean;
+export interface Bn254G2Mul {
+  point: Bn254G2Point;
+  scalar: Fr;
 }
 
-interface MsgpackCircuitVerifyResponse {
-  verified: boolean;
+interface MsgpackBn254G2Mul {
+  point: MsgpackBn254G2Point;
+  scalar: Uint8Array;
 }
 
-export interface CircuitWriteSolidityVerifier {
-  verificationKey: Uint8Array;
-  settings: ProofSystemSettings;
+export interface Bn254G2MulResponse {
+  point: Bn254G2Point;
 }
 
-interface MsgpackCircuitWriteSolidityVerifier {
-  verification_key: Uint8Array;
-  settings: MsgpackProofSystemSettings;
+interface MsgpackBn254G2MulResponse {
+  point: MsgpackBn254G2Point;
 }
 
-export interface CircuitWriteSolidityVerifierResponse {
-  solidityCode: string;
+export interface Bn254G2Point {
+  x: Field2;
+  y: Field2;
 }
 
-interface MsgpackCircuitWriteSolidityVerifierResponse {
-  solidity_code: string;
+interface MsgpackBn254G2Point {
+  x: [Uint8Array, Uint8Array];
+  y: [Uint8Array, Uint8Array];
 }
 
-export interface ClientIvcAccumulate {
+export interface ChonkAccumulate {
   witness: Uint8Array;
 }
 
-interface MsgpackClientIvcAccumulate {
+interface MsgpackChonkAccumulate {
   witness: Uint8Array;
 }
 
-export interface ClientIvcAccumulateResponse {
+export interface ChonkAccumulateResponse {
 }
 
-interface MsgpackClientIvcAccumulateResponse {
+interface MsgpackChonkAccumulateResponse {
 }
 
-export interface ClientIvcCheckPrecomputedVk {
+export interface ChonkCheckPrecomputedVk {
   circuit: CircuitInput;
 }
 
-interface MsgpackClientIvcCheckPrecomputedVk {
+interface MsgpackChonkCheckPrecomputedVk {
   circuit: MsgpackCircuitInput;
 }
 
-export interface ClientIvcCheckPrecomputedVkResponse {
+export interface ChonkCheckPrecomputedVkResponse {
   valid: boolean;
   actualVk: Uint8Array;
 }
 
-interface MsgpackClientIvcCheckPrecomputedVkResponse {
+interface MsgpackChonkCheckPrecomputedVkResponse {
   valid: boolean;
   actual_vk: Uint8Array;
 }
 
-export interface ClientIvcComputeIvcVk {
+export interface ChonkComputeIvcVk {
   circuit: CircuitInputNoVK;
 }
 
-interface MsgpackClientIvcComputeIvcVk {
+interface MsgpackChonkComputeIvcVk {
   circuit: MsgpackCircuitInputNoVK;
 }
 
-export interface ClientIvcComputeIvcVkResponse {
+export interface ChonkComputeIvcVkResponse {
   bytes: Uint8Array;
 }
 
-interface MsgpackClientIvcComputeIvcVkResponse {
+interface MsgpackChonkComputeIvcVkResponse {
   bytes: Uint8Array;
 }
 
-export interface ClientIvcComputeStandaloneVk {
+export interface ChonkComputeStandaloneVk {
   circuit: CircuitInputNoVK;
 }
 
-interface MsgpackClientIvcComputeStandaloneVk {
+interface MsgpackChonkComputeStandaloneVk {
   circuit: MsgpackCircuitInputNoVK;
 }
 
-export interface ClientIvcComputeStandaloneVkResponse {
+export interface ChonkComputeStandaloneVkResponse {
   bytes: Uint8Array;
   fields: Fr[];
 }
 
-interface MsgpackClientIvcComputeStandaloneVkResponse {
+interface MsgpackChonkComputeStandaloneVkResponse {
   bytes: Uint8Array;
   fields: Uint8Array[];
 }
 
-export interface ClientIvcLoad {
+export interface ChonkLoad {
   circuit: CircuitInput;
 }
 
-interface MsgpackClientIvcLoad {
+interface MsgpackChonkLoad {
   circuit: MsgpackCircuitInput;
 }
 
-export interface ClientIvcLoadResponse {
+export interface ChonkLoadResponse {
 }
 
-interface MsgpackClientIvcLoadResponse {
+interface MsgpackChonkLoadResponse {
 }
 
-export interface ClientIVCProof {
+export interface ChonkProof {
   megaProof: Fr[];
   goblinProof: GoblinProof;
 }
 
-interface MsgpackClientIVCProof {
+interface MsgpackChonkProof {
   mega_proof: Uint8Array[];
   goblin_proof: MsgpackGoblinProof;
 }
 
-export interface ClientIvcProve {
+export interface ChonkProve {
 }
 
-interface MsgpackClientIvcProve {
+interface MsgpackChonkProve {
 }
 
-export interface ClientIvcProveResponse {
-  proof: ClientIVCProof;
+export interface ChonkProveResponse {
+  proof: ChonkProof;
 }
 
-interface MsgpackClientIvcProveResponse {
-  proof: MsgpackClientIVCProof;
+interface MsgpackChonkProveResponse {
+  proof: MsgpackChonkProof;
 }
 
-export interface ClientIvcStart {
+export interface ChonkStart {
   numCircuits: number;
 }
 
-interface MsgpackClientIvcStart {
+interface MsgpackChonkStart {
   num_circuits: number;
 }
 
-export interface ClientIvcStartResponse {
+export interface ChonkStartResponse {
 }
 
-interface MsgpackClientIvcStartResponse {
+interface MsgpackChonkStartResponse {
 }
 
-export interface ClientIvcStats {
+export interface ChonkStats {
   circuit: CircuitInputNoVK;
   includeGatesPerOpcode: boolean;
 }
 
-interface MsgpackClientIvcStats {
+interface MsgpackChonkStats {
   circuit: MsgpackCircuitInputNoVK;
   include_gates_per_opcode: boolean;
 }
 
-export interface ClientIvcStatsResponse {
+export interface ChonkStatsResponse {
   acirOpcodes: number;
   circuitSize: number;
   gatesPerOpcode: number[];
 }
 
-interface MsgpackClientIvcStatsResponse {
+interface MsgpackChonkStatsResponse {
   acir_opcodes: number;
   circuit_size: number;
   gates_per_opcode: number[];
 }
 
-export interface ClientIvcVerify {
-  proof: ClientIVCProof;
+export interface ChonkVerify {
+  proof: ChonkProof;
   vk: Uint8Array;
 }
 
-interface MsgpackClientIvcVerify {
-  proof: MsgpackClientIVCProof;
+interface MsgpackChonkVerify {
+  proof: MsgpackChonkProof;
   vk: Uint8Array;
 }
 
-export interface ClientIvcVerifyResponse {
+export interface ChonkVerifyResponse {
   valid: boolean;
 }
 
-interface MsgpackClientIvcVerifyResponse {
+interface MsgpackChonkVerifyResponse {
   valid: boolean;
 }
 
-export interface ECCVMProof {
-  preIpaProof: Fr[];
-  ipaProof: Fr[];
+export interface CircuitComputeVk {
+  circuit: CircuitInputNoVK;
+  settings: ProofSystemSettings;
 }
 
-interface MsgpackECCVMProof {
-  pre_ipa_proof: Uint8Array[];
-  ipa_proof: Uint8Array[];
+interface MsgpackCircuitComputeVk {
+  circuit: MsgpackCircuitInputNoVK;
+  settings: MsgpackProofSystemSettings;
 }
 
-export interface EcdsaSecp256k1ComputePublicKey {
-  privateKey: Secp256k1Fr;
+export interface CircuitComputeVkResponse {
+  bytes: Uint8Array;
+  fields: Uint256T[];
+  hash: Uint8Array;
 }
 
-interface MsgpackEcdsaSecp256k1ComputePublicKey {
-  private_key: Uint8Array;
+interface MsgpackCircuitComputeVkResponse {
+  bytes: Uint8Array;
+  fields: Uint8Array[];
+  hash: Uint8Array;
 }
 
-export interface EcdsaSecp256k1ComputePublicKeyResponse {
-  publicKey: AffineElement;
+export interface CircuitInfoResponse {
+  numGates: number;
+  numGatesDyadic: number;
+  numAcirOpcodes: number;
+  gatesPerOpcode: number[];
 }
 
-interface MsgpackEcdsaSecp256k1ComputePublicKeyResponse {
-  public_key: MsgpackAffineElement;
+interface MsgpackCircuitInfoResponse {
+  num_gates: number;
+  num_gates_dyadic: number;
+  num_acir_opcodes: number;
+  gates_per_opcode: number[];
 }
 
-export interface EcdsaSecp256k1ConstructSignature {
-  message: Uint8Array;
-  privateKey: Secp256k1Fr;
+export interface CircuitInput {
+  name: string;
+  bytecode: Uint8Array;
+  verificationKey: Uint8Array;
 }
 
-interface MsgpackEcdsaSecp256k1ConstructSignature {
-  message: Uint8Array;
-  private_key: Uint8Array;
+interface MsgpackCircuitInput {
+  name: string;
+  bytecode: Uint8Array;
+  verification_key: Uint8Array;
 }
 
-export interface EcdsaSecp256k1ConstructSignatureResponse {
-  r: Uint8Array;
-  s: Uint8Array;
-  v: number;
+export interface CircuitInputNoVK {
+  name: string;
+  bytecode: Uint8Array;
 }
 
-interface MsgpackEcdsaSecp256k1ConstructSignatureResponse {
-  r: Uint8Array;
-  s: Uint8Array;
-  v: number;
+interface MsgpackCircuitInputNoVK {
+  name: string;
+  bytecode: Uint8Array;
 }
 
-export interface EcdsaSecp256k1RecoverPublicKey {
-  message: Uint8Array;
-  r: Uint8Array;
-  s: Uint8Array;
-  v: number;
+export interface CircuitProve {
+  circuit: CircuitInput;
+  witness: Uint8Array;
+  settings: ProofSystemSettings;
 }
 
-interface MsgpackEcdsaSecp256k1RecoverPublicKey {
-  message: Uint8Array;
-  r: Uint8Array;
-  s: Uint8Array;
-  v: number;
+interface MsgpackCircuitProve {
+  circuit: MsgpackCircuitInput;
+  witness: Uint8Array;
+  settings: MsgpackProofSystemSettings;
 }
 
-export interface EcdsaSecp256k1RecoverPublicKeyResponse {
-  publicKey: AffineElement;
+export interface CircuitProveResponse {
+  publicInputs: Uint256T[];
+  proof: Uint256T[];
+  vk: CircuitComputeVkResponse;
 }
 
-interface MsgpackEcdsaSecp256k1RecoverPublicKeyResponse {
-  public_key: MsgpackAffineElement;
+interface MsgpackCircuitProveResponse {
+  public_inputs: Uint8Array[];
+  proof: Uint8Array[];
+  vk: MsgpackCircuitComputeVkResponse;
 }
 
-export interface EcdsaSecp256k1VerifySignature {
-  message: Uint8Array;
-  publicKey: AffineElement;
-  r: Uint8Array;
-  s: Uint8Array;
-  v: number;
+export interface CircuitStats {
+  circuit: CircuitInput;
+  includeGatesPerOpcode: boolean;
+  settings: ProofSystemSettings;
 }
 
-interface MsgpackEcdsaSecp256k1VerifySignature {
-  message: Uint8Array;
-  public_key: MsgpackAffineElement;
-  r: Uint8Array;
-  s: Uint8Array;
-  v: number;
+interface MsgpackCircuitStats {
+  circuit: MsgpackCircuitInput;
+  include_gates_per_opcode: boolean;
+  settings: MsgpackProofSystemSettings;
 }
 
-export interface EcdsaSecp256k1VerifySignatureResponse {
-  verified: boolean;
+export interface CircuitVerify {
+  verificationKey: Uint8Array;
+  publicInputs: Uint256T[];
+  proof: Uint256T[];
+  settings: ProofSystemSettings;
 }
 
-interface MsgpackEcdsaSecp256k1VerifySignatureResponse {
+interface MsgpackCircuitVerify {
+  verification_key: Uint8Array;
+  public_inputs: Uint8Array[];
+  proof: Uint8Array[];
+  settings: MsgpackProofSystemSettings;
+}
+
+export interface CircuitVerifyResponse {
+  verified: boolean;
+}
+
+interface MsgpackCircuitVerifyResponse {
+  verified: boolean;
+}
+
+export interface CircuitWriteSolidityVerifier {
+  verificationKey: Uint8Array;
+  settings: ProofSystemSettings;
+}
+
+interface MsgpackCircuitWriteSolidityVerifier {
+  verification_key: Uint8Array;
+  settings: MsgpackProofSystemSettings;
+}
+
+export interface CircuitWriteSolidityVerifierResponse {
+  solidityCode: string;
+}
+
+interface MsgpackCircuitWriteSolidityVerifierResponse {
+  solidity_code: string;
+}
+
+export interface EcdsaSecp256k1ComputePublicKey {
+  privateKey: Secp256k1Fr;
+}
+
+interface MsgpackEcdsaSecp256k1ComputePublicKey {
+  private_key: Uint8Array;
+}
+
+export interface EcdsaSecp256k1ComputePublicKeyResponse {
+  publicKey: Secp256k1Point;
+}
+
+interface MsgpackEcdsaSecp256k1ComputePublicKeyResponse {
+  public_key: MsgpackSecp256k1Point;
+}
+
+export interface EcdsaSecp256k1ConstructSignature {
+  message: Uint8Array;
+  privateKey: Secp256k1Fr;
+}
+
+interface MsgpackEcdsaSecp256k1ConstructSignature {
+  message: Uint8Array;
+  private_key: Uint8Array;
+}
+
+export interface EcdsaSecp256k1ConstructSignatureResponse {
+  r: Uint8Array;
+  s: Uint8Array;
+  v: number;
+}
+
+interface MsgpackEcdsaSecp256k1ConstructSignatureResponse {
+  r: Uint8Array;
+  s: Uint8Array;
+  v: number;
+}
+
+export interface EcdsaSecp256k1RecoverPublicKey {
+  message: Uint8Array;
+  r: Uint8Array;
+  s: Uint8Array;
+  v: number;
+}
+
+interface MsgpackEcdsaSecp256k1RecoverPublicKey {
+  message: Uint8Array;
+  r: Uint8Array;
+  s: Uint8Array;
+  v: number;
+}
+
+export interface EcdsaSecp256k1RecoverPublicKeyResponse {
+  publicKey: Secp256k1Point;
+}
+
+interface MsgpackEcdsaSecp256k1RecoverPublicKeyResponse {
+  public_key: MsgpackSecp256k1Point;
+}
+
+export interface EcdsaSecp256k1VerifySignature {
+  message: Uint8Array;
+  publicKey: Secp256k1Point;
+  r: Uint8Array;
+  s: Uint8Array;
+  v: number;
+}
+
+interface MsgpackEcdsaSecp256k1VerifySignature {
+  message: Uint8Array;
+  public_key: MsgpackSecp256k1Point;
+  r: Uint8Array;
+  s: Uint8Array;
+  v: number;
+}
+
+export interface EcdsaSecp256k1VerifySignatureResponse {
+  verified: boolean;
+}
+
+interface MsgpackEcdsaSecp256k1VerifySignatureResponse {
   verified: boolean;
 }
 
@@ -1487,11 +1702,11 @@ interface MsgpackEcdsaSecp256r1ComputePublicKey {
 }
 
 export interface EcdsaSecp256r1ComputePublicKeyResponse {
-  publicKey: AffineElement;
+  publicKey: Secp256r1Point;
 }
 
 interface MsgpackEcdsaSecp256r1ComputePublicKeyResponse {
-  public_key: MsgpackAffineElement;
+  public_key: MsgpackSecp256r1Point;
 }
 
 export interface EcdsaSecp256r1ConstructSignature {
@@ -1531,16 +1746,16 @@ interface MsgpackEcdsaSecp256r1RecoverPublicKey {
 }
 
 export interface EcdsaSecp256r1RecoverPublicKeyResponse {
-  publicKey: AffineElement;
+  publicKey: Secp256r1Point;
 }
 
 interface MsgpackEcdsaSecp256r1RecoverPublicKeyResponse {
-  public_key: MsgpackAffineElement;
+  public_key: MsgpackSecp256r1Point;
 }
 
 export interface EcdsaSecp256r1VerifySignature {
   message: Uint8Array;
-  publicKey: AffineElement;
+  publicKey: Secp256r1Point;
   r: Uint8Array;
   s: Uint8Array;
   v: number;
@@ -1548,7 +1763,7 @@ export interface EcdsaSecp256r1VerifySignature {
 
 interface MsgpackEcdsaSecp256r1VerifySignature {
   message: Uint8Array;
-  public_key: MsgpackAffineElement;
+  public_key: MsgpackSecp256r1Point;
   r: Uint8Array;
   s: Uint8Array;
   v: number;
@@ -1562,52 +1777,62 @@ interface MsgpackEcdsaSecp256r1VerifySignatureResponse {
   verified: boolean;
 }
 
+export interface ErrorResponse {
+  message: string;
+}
+
+interface MsgpackErrorResponse {
+  message: string;
+}
+
 export interface GoblinProof {
   mergeProof: Fr[];
-  eccvmProof: ECCVMProof;
+  eccvmProof: Fr[];
+  ipaProof: Fr[];
   translatorProof: Fr[];
 }
 
 interface MsgpackGoblinProof {
   merge_proof: Uint8Array[];
-  eccvm_proof: MsgpackECCVMProof;
+  eccvm_proof: Uint8Array[];
+  ipa_proof: Uint8Array[];
   translator_proof: Uint8Array[];
 }
 
 export interface GrumpkinAdd {
-  pointA: AffineElement;
-  pointB: AffineElement;
+  pointA: GrumpkinPoint;
+  pointB: GrumpkinPoint;
 }
 
 interface MsgpackGrumpkinAdd {
-  point_a: MsgpackAffineElement;
-  point_b: MsgpackAffineElement;
+  point_a: MsgpackGrumpkinPoint;
+  point_b: MsgpackGrumpkinPoint;
 }
 
 export interface GrumpkinAddResponse {
-  point: AffineElement;
+  point: GrumpkinPoint;
 }
 
 interface MsgpackGrumpkinAddResponse {
-  point: MsgpackAffineElement;
+  point: MsgpackGrumpkinPoint;
 }
 
 export interface GrumpkinBatchMul {
-  points: AffineElement[];
+  points: GrumpkinPoint[];
   scalar: Fq;
 }
 
 interface MsgpackGrumpkinBatchMul {
-  points: MsgpackAffineElement[];
+  points: MsgpackGrumpkinPoint[];
   scalar: Uint8Array;
 }
 
 export interface GrumpkinBatchMulResponse {
-  points: AffineElement[];
+  points: GrumpkinPoint[];
 }
 
 interface MsgpackGrumpkinBatchMulResponse {
-  points: MsgpackAffineElement[];
+  points: MsgpackGrumpkinPoint[];
 }
 
 export interface GrumpkinGetRandomFr {
@@ -1627,21 +1852,31 @@ interface MsgpackGrumpkinGetRandomFrResponse {
 }
 
 export interface GrumpkinMul {
-  point: AffineElement;
+  point: GrumpkinPoint;
   scalar: Fq;
 }
 
 interface MsgpackGrumpkinMul {
-  point: MsgpackAffineElement;
+  point: MsgpackGrumpkinPoint;
   scalar: Uint8Array;
 }
 
 export interface GrumpkinMulResponse {
-  point: AffineElement;
+  point: GrumpkinPoint;
 }
 
 interface MsgpackGrumpkinMulResponse {
-  point: MsgpackAffineElement;
+  point: MsgpackGrumpkinPoint;
+}
+
+export interface GrumpkinPoint {
+  x: Fr;
+  y: Fr;
+}
+
+interface MsgpackGrumpkinPoint {
+  x: Uint8Array;
+  y: Uint8Array;
 }
 
 export interface GrumpkinReduce512 {
@@ -1687,11 +1922,11 @@ interface MsgpackPedersenCommit {
 }
 
 export interface PedersenCommitResponse {
-  point: AffineElement;
+  point: GrumpkinPoint;
 }
 
 interface MsgpackPedersenCommitResponse {
-  point: MsgpackAffineElement;
+  point: MsgpackGrumpkinPoint;
 }
 
 export interface PedersenHash {
@@ -1801,11 +2036,11 @@ interface MsgpackSchnorrComputePublicKey {
 }
 
 export interface SchnorrComputePublicKeyResponse {
-  publicKey: AffineElement;
+  publicKey: GrumpkinPoint;
 }
 
 interface MsgpackSchnorrComputePublicKeyResponse {
-  public_key: MsgpackAffineElement;
+  public_key: MsgpackGrumpkinPoint;
 }
 
 export interface SchnorrConstructSignature {
@@ -1830,14 +2065,14 @@ interface MsgpackSchnorrConstructSignatureResponse {
 
 export interface SchnorrVerifySignature {
   message: Uint8Array;
-  publicKey: AffineElement;
+  publicKey: GrumpkinPoint;
   s: Uint8Array;
   e: Uint8Array;
 }
 
 interface MsgpackSchnorrVerifySignature {
   message: Uint8Array;
-  public_key: MsgpackAffineElement;
+  public_key: MsgpackGrumpkinPoint;
   s: Uint8Array;
   e: Uint8Array;
 }
@@ -1867,21 +2102,31 @@ interface MsgpackSecp256k1GetRandomFrResponse {
 }
 
 export interface Secp256k1Mul {
-  point: AffineElement;
+  point: Secp256k1Point;
   scalar: Secp256k1Fr;
 }
 
 interface MsgpackSecp256k1Mul {
-  point: MsgpackAffineElement;
+  point: MsgpackSecp256k1Point;
   scalar: Uint8Array;
 }
 
 export interface Secp256k1MulResponse {
-  point: AffineElement;
+  point: Secp256k1Point;
 }
 
 interface MsgpackSecp256k1MulResponse {
-  point: MsgpackAffineElement;
+  point: MsgpackSecp256k1Point;
+}
+
+export interface Secp256k1Point {
+  x: Secp256k1Fq;
+  y: Secp256k1Fq;
+}
+
+interface MsgpackSecp256k1Point {
+  x: Uint8Array;
+  y: Uint8Array;
 }
 
 export interface Secp256k1Reduce512 {
@@ -1900,6 +2145,16 @@ interface MsgpackSecp256k1Reduce512Response {
   value: Uint8Array;
 }
 
+export interface Secp256r1Point {
+  x: Secp256r1Fq;
+  y: Secp256r1Fq;
+}
+
+interface MsgpackSecp256r1Point {
+  x: Uint8Array;
+  y: Uint8Array;
+}
+
 export interface Shutdown {
 }
 
@@ -2047,24 +2302,6 @@ export function fromAesEncryptResponse(o: AesEncryptResponse): MsgpackAesEncrypt
   };
 }
 
-export function toAffineElement(o: MsgpackAffineElement): AffineElement {
-  if (o.x === undefined) { throw new Error("Expected x in AffineElement deserialization"); }
-  if (o.y === undefined) { throw new Error("Expected y in AffineElement deserialization"); };
-  return {
-    x: o.x,
-    y: o.y,
-  };
-}
-
-export function fromAffineElement(o: AffineElement): MsgpackAffineElement {
-  if (o.x === undefined) { throw new Error("Expected x in AffineElement serialization"); }
-  if (o.y === undefined) { throw new Error("Expected y in AffineElement serialization"); };
-  return {
-  x: o.x,
-  y: o.y,
-  };
-}
-
 export function toBlake2s(o: MsgpackBlake2s): Blake2s {
   if (o.data === undefined) { throw new Error("Expected data in Blake2s deserialization"); };
   return {
@@ -2121,6 +2358,38 @@ export function fromBlake2sToFieldResponse(o: Blake2sToFieldResponse): MsgpackBl
   };
 }
 
+export function toBn254FqSqrt(o: MsgpackBn254FqSqrt): Bn254FqSqrt {
+  if (o.input === undefined) { throw new Error("Expected input in Bn254FqSqrt deserialization"); };
+  return {
+    input: o.input,
+  };
+}
+
+export function fromBn254FqSqrt(o: Bn254FqSqrt): MsgpackBn254FqSqrt {
+  if (o.input === undefined) { throw new Error("Expected input in Bn254FqSqrt serialization"); };
+  return {
+  input: o.input,
+  };
+}
+
+export function toBn254FqSqrtResponse(o: MsgpackBn254FqSqrtResponse): Bn254FqSqrtResponse {
+  if (o.is_square_root === undefined) { throw new Error("Expected is_square_root in Bn254FqSqrtResponse deserialization"); }
+  if (o.value === undefined) { throw new Error("Expected value in Bn254FqSqrtResponse deserialization"); };
+  return {
+    isSquareRoot: o.is_square_root,
+    value: o.value,
+  };
+}
+
+export function fromBn254FqSqrtResponse(o: Bn254FqSqrtResponse): MsgpackBn254FqSqrtResponse {
+  if (o.isSquareRoot === undefined) { throw new Error("Expected isSquareRoot in Bn254FqSqrtResponse serialization"); }
+  if (o.value === undefined) { throw new Error("Expected value in Bn254FqSqrtResponse serialization"); };
+  return {
+  is_square_root: o.isSquareRoot,
+  value: o.value,
+  };
+}
+
 export function toBn254FrSqrt(o: MsgpackBn254FrSqrt): Bn254FrSqrt {
   if (o.input === undefined) { throw new Error("Expected input in Bn254FrSqrt deserialization"); };
   return {
@@ -2131,25 +2400,451 @@ export function toBn254FrSqrt(o: MsgpackBn254FrSqrt): Bn254FrSqrt {
 export function fromBn254FrSqrt(o: Bn254FrSqrt): MsgpackBn254FrSqrt {
   if (o.input === undefined) { throw new Error("Expected input in Bn254FrSqrt serialization"); };
   return {
-  input: o.input,
+  input: o.input,
+  };
+}
+
+export function toBn254FrSqrtResponse(o: MsgpackBn254FrSqrtResponse): Bn254FrSqrtResponse {
+  if (o.is_square_root === undefined) { throw new Error("Expected is_square_root in Bn254FrSqrtResponse deserialization"); }
+  if (o.value === undefined) { throw new Error("Expected value in Bn254FrSqrtResponse deserialization"); };
+  return {
+    isSquareRoot: o.is_square_root,
+    value: o.value,
+  };
+}
+
+export function fromBn254FrSqrtResponse(o: Bn254FrSqrtResponse): MsgpackBn254FrSqrtResponse {
+  if (o.isSquareRoot === undefined) { throw new Error("Expected isSquareRoot in Bn254FrSqrtResponse serialization"); }
+  if (o.value === undefined) { throw new Error("Expected value in Bn254FrSqrtResponse serialization"); };
+  return {
+  is_square_root: o.isSquareRoot,
+  value: o.value,
+  };
+}
+
+export function toBn254G1FromCompressed(o: MsgpackBn254G1FromCompressed): Bn254G1FromCompressed {
+  if (o.compressed === undefined) { throw new Error("Expected compressed in Bn254G1FromCompressed deserialization"); };
+  return {
+    compressed: o.compressed,
+  };
+}
+
+export function fromBn254G1FromCompressed(o: Bn254G1FromCompressed): MsgpackBn254G1FromCompressed {
+  if (o.compressed === undefined) { throw new Error("Expected compressed in Bn254G1FromCompressed serialization"); };
+  return {
+  compressed: o.compressed,
+  };
+}
+
+export function toBn254G1FromCompressedResponse(o: MsgpackBn254G1FromCompressedResponse): Bn254G1FromCompressedResponse {
+  if (o.point === undefined) { throw new Error("Expected point in Bn254G1FromCompressedResponse deserialization"); };
+  return {
+    point: toBn254G1Point(o.point),
+  };
+}
+
+export function fromBn254G1FromCompressedResponse(o: Bn254G1FromCompressedResponse): MsgpackBn254G1FromCompressedResponse {
+  if (o.point === undefined) { throw new Error("Expected point in Bn254G1FromCompressedResponse serialization"); };
+  return {
+  point: fromBn254G1Point(o.point),
+  };
+}
+
+export function toBn254G1IsOnCurve(o: MsgpackBn254G1IsOnCurve): Bn254G1IsOnCurve {
+  if (o.point === undefined) { throw new Error("Expected point in Bn254G1IsOnCurve deserialization"); };
+  return {
+    point: toBn254G1Point(o.point),
+  };
+}
+
+export function fromBn254G1IsOnCurve(o: Bn254G1IsOnCurve): MsgpackBn254G1IsOnCurve {
+  if (o.point === undefined) { throw new Error("Expected point in Bn254G1IsOnCurve serialization"); };
+  return {
+  point: fromBn254G1Point(o.point),
+  };
+}
+
+export function toBn254G1IsOnCurveResponse(o: MsgpackBn254G1IsOnCurveResponse): Bn254G1IsOnCurveResponse {
+  if (o.is_on_curve === undefined) { throw new Error("Expected is_on_curve in Bn254G1IsOnCurveResponse deserialization"); };
+  return {
+    isOnCurve: o.is_on_curve,
+  };
+}
+
+export function fromBn254G1IsOnCurveResponse(o: Bn254G1IsOnCurveResponse): MsgpackBn254G1IsOnCurveResponse {
+  if (o.isOnCurve === undefined) { throw new Error("Expected isOnCurve in Bn254G1IsOnCurveResponse serialization"); };
+  return {
+  is_on_curve: o.isOnCurve,
+  };
+}
+
+export function toBn254G1Mul(o: MsgpackBn254G1Mul): Bn254G1Mul {
+  if (o.point === undefined) { throw new Error("Expected point in Bn254G1Mul deserialization"); }
+  if (o.scalar === undefined) { throw new Error("Expected scalar in Bn254G1Mul deserialization"); };
+  return {
+    point: toBn254G1Point(o.point),
+    scalar: o.scalar,
+  };
+}
+
+export function fromBn254G1Mul(o: Bn254G1Mul): MsgpackBn254G1Mul {
+  if (o.point === undefined) { throw new Error("Expected point in Bn254G1Mul serialization"); }
+  if (o.scalar === undefined) { throw new Error("Expected scalar in Bn254G1Mul serialization"); };
+  return {
+  point: fromBn254G1Point(o.point),
+  scalar: o.scalar,
+  };
+}
+
+export function toBn254G1MulResponse(o: MsgpackBn254G1MulResponse): Bn254G1MulResponse {
+  if (o.point === undefined) { throw new Error("Expected point in Bn254G1MulResponse deserialization"); };
+  return {
+    point: toBn254G1Point(o.point),
+  };
+}
+
+export function fromBn254G1MulResponse(o: Bn254G1MulResponse): MsgpackBn254G1MulResponse {
+  if (o.point === undefined) { throw new Error("Expected point in Bn254G1MulResponse serialization"); };
+  return {
+  point: fromBn254G1Point(o.point),
+  };
+}
+
+export function toBn254G1Point(o: MsgpackBn254G1Point): Bn254G1Point {
+  if (o.x === undefined) { throw new Error("Expected x in Bn254G1Point deserialization"); }
+  if (o.y === undefined) { throw new Error("Expected y in Bn254G1Point deserialization"); };
+  return {
+    x: o.x,
+    y: o.y,
+  };
+}
+
+export function fromBn254G1Point(o: Bn254G1Point): MsgpackBn254G1Point {
+  if (o.x === undefined) { throw new Error("Expected x in Bn254G1Point serialization"); }
+  if (o.y === undefined) { throw new Error("Expected y in Bn254G1Point serialization"); };
+  return {
+  x: o.x,
+  y: o.y,
+  };
+}
+
+export function toBn254G2Mul(o: MsgpackBn254G2Mul): Bn254G2Mul {
+  if (o.point === undefined) { throw new Error("Expected point in Bn254G2Mul deserialization"); }
+  if (o.scalar === undefined) { throw new Error("Expected scalar in Bn254G2Mul deserialization"); };
+  return {
+    point: toBn254G2Point(o.point),
+    scalar: o.scalar,
+  };
+}
+
+export function fromBn254G2Mul(o: Bn254G2Mul): MsgpackBn254G2Mul {
+  if (o.point === undefined) { throw new Error("Expected point in Bn254G2Mul serialization"); }
+  if (o.scalar === undefined) { throw new Error("Expected scalar in Bn254G2Mul serialization"); };
+  return {
+  point: fromBn254G2Point(o.point),
+  scalar: o.scalar,
+  };
+}
+
+export function toBn254G2MulResponse(o: MsgpackBn254G2MulResponse): Bn254G2MulResponse {
+  if (o.point === undefined) { throw new Error("Expected point in Bn254G2MulResponse deserialization"); };
+  return {
+    point: toBn254G2Point(o.point),
+  };
+}
+
+export function fromBn254G2MulResponse(o: Bn254G2MulResponse): MsgpackBn254G2MulResponse {
+  if (o.point === undefined) { throw new Error("Expected point in Bn254G2MulResponse serialization"); };
+  return {
+  point: fromBn254G2Point(o.point),
+  };
+}
+
+export function toBn254G2Point(o: MsgpackBn254G2Point): Bn254G2Point {
+  if (o.x === undefined) { throw new Error("Expected x in Bn254G2Point deserialization"); }
+  if (o.y === undefined) { throw new Error("Expected y in Bn254G2Point deserialization"); };
+  return {
+    x: o.x,
+    y: o.y,
+  };
+}
+
+export function fromBn254G2Point(o: Bn254G2Point): MsgpackBn254G2Point {
+  if (o.x === undefined) { throw new Error("Expected x in Bn254G2Point serialization"); }
+  if (o.y === undefined) { throw new Error("Expected y in Bn254G2Point serialization"); };
+  return {
+  x: o.x,
+  y: o.y,
+  };
+}
+
+export function toChonkAccumulate(o: MsgpackChonkAccumulate): ChonkAccumulate {
+  if (o.witness === undefined) { throw new Error("Expected witness in ChonkAccumulate deserialization"); };
+  return {
+    witness: o.witness,
+  };
+}
+
+export function fromChonkAccumulate(o: ChonkAccumulate): MsgpackChonkAccumulate {
+  if (o.witness === undefined) { throw new Error("Expected witness in ChonkAccumulate serialization"); };
+  return {
+  witness: o.witness,
+  };
+}
+
+export function toChonkAccumulateResponse(o: MsgpackChonkAccumulateResponse): ChonkAccumulateResponse {
+  return {};
+}
+
+export function fromChonkAccumulateResponse(o: ChonkAccumulateResponse): MsgpackChonkAccumulateResponse {
+  return {};
+}
+
+export function toChonkCheckPrecomputedVk(o: MsgpackChonkCheckPrecomputedVk): ChonkCheckPrecomputedVk {
+  if (o.circuit === undefined) { throw new Error("Expected circuit in ChonkCheckPrecomputedVk deserialization"); };
+  return {
+    circuit: toCircuitInput(o.circuit),
+  };
+}
+
+export function fromChonkCheckPrecomputedVk(o: ChonkCheckPrecomputedVk): MsgpackChonkCheckPrecomputedVk {
+  if (o.circuit === undefined) { throw new Error("Expected circuit in ChonkCheckPrecomputedVk serialization"); };
+  return {
+  circuit: fromCircuitInput(o.circuit),
+  };
+}
+
+export function toChonkCheckPrecomputedVkResponse(o: MsgpackChonkCheckPrecomputedVkResponse): ChonkCheckPrecomputedVkResponse {
+  if (o.valid === undefined) { throw new Error("Expected valid in ChonkCheckPrecomputedVkResponse deserialization"); }
+  if (o.actual_vk === undefined) { throw new Error("Expected actual_vk in ChonkCheckPrecomputedVkResponse deserialization"); };
+  return {
+    valid: o.valid,
+    actualVk: o.actual_vk,
+  };
+}
+
+export function fromChonkCheckPrecomputedVkResponse(o: ChonkCheckPrecomputedVkResponse): MsgpackChonkCheckPrecomputedVkResponse {
+  if (o.valid === undefined) { throw new Error("Expected valid in ChonkCheckPrecomputedVkResponse serialization"); }
+  if (o.actualVk === undefined) { throw new Error("Expected actualVk in ChonkCheckPrecomputedVkResponse serialization"); };
+  return {
+  valid: o.valid,
+  actual_vk: o.actualVk,
+  };
+}
+
+export function toChonkComputeIvcVk(o: MsgpackChonkComputeIvcVk): ChonkComputeIvcVk {
+  if (o.circuit === undefined) { throw new Error("Expected circuit in ChonkComputeIvcVk deserialization"); };
+  return {
+    circuit: toCircuitInputNoVK(o.circuit),
+  };
+}
+
+export function fromChonkComputeIvcVk(o: ChonkComputeIvcVk): MsgpackChonkComputeIvcVk {
+  if (o.circuit === undefined) { throw new Error("Expected circuit in ChonkComputeIvcVk serialization"); };
+  return {
+  circuit: fromCircuitInputNoVK(o.circuit),
+  };
+}
+
+export function toChonkComputeIvcVkResponse(o: MsgpackChonkComputeIvcVkResponse): ChonkComputeIvcVkResponse {
+  if (o.bytes === undefined) { throw new Error("Expected bytes in ChonkComputeIvcVkResponse deserialization"); };
+  return {
+    bytes: o.bytes,
+  };
+}
+
+export function fromChonkComputeIvcVkResponse(o: ChonkComputeIvcVkResponse): MsgpackChonkComputeIvcVkResponse {
+  if (o.bytes === undefined) { throw new Error("Expected bytes in ChonkComputeIvcVkResponse serialization"); };
+  return {
+  bytes: o.bytes,
+  };
+}
+
+export function toChonkComputeStandaloneVk(o: MsgpackChonkComputeStandaloneVk): ChonkComputeStandaloneVk {
+  if (o.circuit === undefined) { throw new Error("Expected circuit in ChonkComputeStandaloneVk deserialization"); };
+  return {
+    circuit: toCircuitInputNoVK(o.circuit),
+  };
+}
+
+export function fromChonkComputeStandaloneVk(o: ChonkComputeStandaloneVk): MsgpackChonkComputeStandaloneVk {
+  if (o.circuit === undefined) { throw new Error("Expected circuit in ChonkComputeStandaloneVk serialization"); };
+  return {
+  circuit: fromCircuitInputNoVK(o.circuit),
+  };
+}
+
+export function toChonkComputeStandaloneVkResponse(o: MsgpackChonkComputeStandaloneVkResponse): ChonkComputeStandaloneVkResponse {
+  if (o.bytes === undefined) { throw new Error("Expected bytes in ChonkComputeStandaloneVkResponse deserialization"); }
+  if (o.fields === undefined) { throw new Error("Expected fields in ChonkComputeStandaloneVkResponse deserialization"); };
+  return {
+    bytes: o.bytes,
+    fields: o.fields.map((v: any) => v),
+  };
+}
+
+export function fromChonkComputeStandaloneVkResponse(o: ChonkComputeStandaloneVkResponse): MsgpackChonkComputeStandaloneVkResponse {
+  if (o.bytes === undefined) { throw new Error("Expected bytes in ChonkComputeStandaloneVkResponse serialization"); }
+  if (o.fields === undefined) { throw new Error("Expected fields in ChonkComputeStandaloneVkResponse serialization"); };
+  return {
+  bytes: o.bytes,
+  fields: o.fields.map((v: any) => v),
+  };
+}
+
+export function toChonkLoad(o: MsgpackChonkLoad): ChonkLoad {
+  if (o.circuit === undefined) { throw new Error("Expected circuit in ChonkLoad deserialization"); };
+  return {
+    circuit: toCircuitInput(o.circuit),
+  };
+}
+
+export function fromChonkLoad(o: ChonkLoad): MsgpackChonkLoad {
+  if (o.circuit === undefined) { throw new Error("Expected circuit in ChonkLoad serialization"); };
+  return {
+  circuit: fromCircuitInput(o.circuit),
+  };
+}
+
+export function toChonkLoadResponse(o: MsgpackChonkLoadResponse): ChonkLoadResponse {
+  return {};
+}
+
+export function fromChonkLoadResponse(o: ChonkLoadResponse): MsgpackChonkLoadResponse {
+  return {};
+}
+
+export function toChonkProof(o: MsgpackChonkProof): ChonkProof {
+  if (o.mega_proof === undefined) { throw new Error("Expected mega_proof in ChonkProof deserialization"); }
+  if (o.goblin_proof === undefined) { throw new Error("Expected goblin_proof in ChonkProof deserialization"); };
+  return {
+    megaProof: o.mega_proof.map((v: any) => v),
+    goblinProof: toGoblinProof(o.goblin_proof),
+  };
+}
+
+export function fromChonkProof(o: ChonkProof): MsgpackChonkProof {
+  if (o.megaProof === undefined) { throw new Error("Expected megaProof in ChonkProof serialization"); }
+  if (o.goblinProof === undefined) { throw new Error("Expected goblinProof in ChonkProof serialization"); };
+  return {
+  mega_proof: o.megaProof.map((v: any) => v),
+  goblin_proof: fromGoblinProof(o.goblinProof),
+  };
+}
+
+export function toChonkProve(o: MsgpackChonkProve): ChonkProve {
+  return {};
+}
+
+export function fromChonkProve(o: ChonkProve): MsgpackChonkProve {
+  return {};
+}
+
+export function toChonkProveResponse(o: MsgpackChonkProveResponse): ChonkProveResponse {
+  if (o.proof === undefined) { throw new Error("Expected proof in ChonkProveResponse deserialization"); };
+  return {
+    proof: toChonkProof(o.proof),
+  };
+}
+
+export function fromChonkProveResponse(o: ChonkProveResponse): MsgpackChonkProveResponse {
+  if (o.proof === undefined) { throw new Error("Expected proof in ChonkProveResponse serialization"); };
+  return {
+  proof: fromChonkProof(o.proof),
+  };
+}
+
+export function toChonkStart(o: MsgpackChonkStart): ChonkStart {
+  if (o.num_circuits === undefined) { throw new Error("Expected num_circuits in ChonkStart deserialization"); };
+  return {
+    numCircuits: o.num_circuits,
+  };
+}
+
+export function fromChonkStart(o: ChonkStart): MsgpackChonkStart {
+  if (o.numCircuits === undefined) { throw new Error("Expected numCircuits in ChonkStart serialization"); };
+  return {
+  num_circuits: o.numCircuits,
+  };
+}
+
+export function toChonkStartResponse(o: MsgpackChonkStartResponse): ChonkStartResponse {
+  return {};
+}
+
+export function fromChonkStartResponse(o: ChonkStartResponse): MsgpackChonkStartResponse {
+  return {};
+}
+
+export function toChonkStats(o: MsgpackChonkStats): ChonkStats {
+  if (o.circuit === undefined) { throw new Error("Expected circuit in ChonkStats deserialization"); }
+  if (o.include_gates_per_opcode === undefined) { throw new Error("Expected include_gates_per_opcode in ChonkStats deserialization"); };
+  return {
+    circuit: toCircuitInputNoVK(o.circuit),
+    includeGatesPerOpcode: o.include_gates_per_opcode,
+  };
+}
+
+export function fromChonkStats(o: ChonkStats): MsgpackChonkStats {
+  if (o.circuit === undefined) { throw new Error("Expected circuit in ChonkStats serialization"); }
+  if (o.includeGatesPerOpcode === undefined) { throw new Error("Expected includeGatesPerOpcode in ChonkStats serialization"); };
+  return {
+  circuit: fromCircuitInputNoVK(o.circuit),
+  include_gates_per_opcode: o.includeGatesPerOpcode,
+  };
+}
+
+export function toChonkStatsResponse(o: MsgpackChonkStatsResponse): ChonkStatsResponse {
+  if (o.acir_opcodes === undefined) { throw new Error("Expected acir_opcodes in ChonkStatsResponse deserialization"); }
+  if (o.circuit_size === undefined) { throw new Error("Expected circuit_size in ChonkStatsResponse deserialization"); }
+  if (o.gates_per_opcode === undefined) { throw new Error("Expected gates_per_opcode in ChonkStatsResponse deserialization"); };
+  return {
+    acirOpcodes: o.acir_opcodes,
+    circuitSize: o.circuit_size,
+    gatesPerOpcode: o.gates_per_opcode.map((v: any) => v),
+  };
+}
+
+export function fromChonkStatsResponse(o: ChonkStatsResponse): MsgpackChonkStatsResponse {
+  if (o.acirOpcodes === undefined) { throw new Error("Expected acirOpcodes in ChonkStatsResponse serialization"); }
+  if (o.circuitSize === undefined) { throw new Error("Expected circuitSize in ChonkStatsResponse serialization"); }
+  if (o.gatesPerOpcode === undefined) { throw new Error("Expected gatesPerOpcode in ChonkStatsResponse serialization"); };
+  return {
+  acir_opcodes: o.acirOpcodes,
+  circuit_size: o.circuitSize,
+  gates_per_opcode: o.gatesPerOpcode.map((v: any) => v),
+  };
+}
+
+export function toChonkVerify(o: MsgpackChonkVerify): ChonkVerify {
+  if (o.proof === undefined) { throw new Error("Expected proof in ChonkVerify deserialization"); }
+  if (o.vk === undefined) { throw new Error("Expected vk in ChonkVerify deserialization"); };
+  return {
+    proof: toChonkProof(o.proof),
+    vk: o.vk,
+  };
+}
+
+export function fromChonkVerify(o: ChonkVerify): MsgpackChonkVerify {
+  if (o.proof === undefined) { throw new Error("Expected proof in ChonkVerify serialization"); }
+  if (o.vk === undefined) { throw new Error("Expected vk in ChonkVerify serialization"); };
+  return {
+  proof: fromChonkProof(o.proof),
+  vk: o.vk,
   };
 }
 
-export function toBn254FrSqrtResponse(o: MsgpackBn254FrSqrtResponse): Bn254FrSqrtResponse {
-  if (o.is_square_root === undefined) { throw new Error("Expected is_square_root in Bn254FrSqrtResponse deserialization"); }
-  if (o.value === undefined) { throw new Error("Expected value in Bn254FrSqrtResponse deserialization"); };
+export function toChonkVerifyResponse(o: MsgpackChonkVerifyResponse): ChonkVerifyResponse {
+  if (o.valid === undefined) { throw new Error("Expected valid in ChonkVerifyResponse deserialization"); };
   return {
-    isSquareRoot: o.is_square_root,
-    value: o.value,
+    valid: o.valid,
   };
 }
 
-export function fromBn254FrSqrtResponse(o: Bn254FrSqrtResponse): MsgpackBn254FrSqrtResponse {
-  if (o.isSquareRoot === undefined) { throw new Error("Expected isSquareRoot in Bn254FrSqrtResponse serialization"); }
-  if (o.value === undefined) { throw new Error("Expected value in Bn254FrSqrtResponse serialization"); };
+export function fromChonkVerifyResponse(o: ChonkVerifyResponse): MsgpackChonkVerifyResponse {
+  if (o.valid === undefined) { throw new Error("Expected valid in ChonkVerifyResponse serialization"); };
   return {
-  is_square_root: o.isSquareRoot,
-  value: o.value,
+  valid: o.valid,
   };
 }
 
@@ -2397,294 +3092,6 @@ export function fromCircuitWriteSolidityVerifierResponse(o: CircuitWriteSolidity
   };
 }
 
-export function toClientIvcAccumulate(o: MsgpackClientIvcAccumulate): ClientIvcAccumulate {
-  if (o.witness === undefined) { throw new Error("Expected witness in ClientIvcAccumulate deserialization"); };
-  return {
-    witness: o.witness,
-  };
-}
-
-export function fromClientIvcAccumulate(o: ClientIvcAccumulate): MsgpackClientIvcAccumulate {
-  if (o.witness === undefined) { throw new Error("Expected witness in ClientIvcAccumulate serialization"); };
-  return {
-  witness: o.witness,
-  };
-}
-
-export function toClientIvcAccumulateResponse(o: MsgpackClientIvcAccumulateResponse): ClientIvcAccumulateResponse {
-  return {};
-}
-
-export function fromClientIvcAccumulateResponse(o: ClientIvcAccumulateResponse): MsgpackClientIvcAccumulateResponse {
-  return {};
-}
-
-export function toClientIvcCheckPrecomputedVk(o: MsgpackClientIvcCheckPrecomputedVk): ClientIvcCheckPrecomputedVk {
-  if (o.circuit === undefined) { throw new Error("Expected circuit in ClientIvcCheckPrecomputedVk deserialization"); };
-  return {
-    circuit: toCircuitInput(o.circuit),
-  };
-}
-
-export function fromClientIvcCheckPrecomputedVk(o: ClientIvcCheckPrecomputedVk): MsgpackClientIvcCheckPrecomputedVk {
-  if (o.circuit === undefined) { throw new Error("Expected circuit in ClientIvcCheckPrecomputedVk serialization"); };
-  return {
-  circuit: fromCircuitInput(o.circuit),
-  };
-}
-
-export function toClientIvcCheckPrecomputedVkResponse(o: MsgpackClientIvcCheckPrecomputedVkResponse): ClientIvcCheckPrecomputedVkResponse {
-  if (o.valid === undefined) { throw new Error("Expected valid in ClientIvcCheckPrecomputedVkResponse deserialization"); }
-  if (o.actual_vk === undefined) { throw new Error("Expected actual_vk in ClientIvcCheckPrecomputedVkResponse deserialization"); };
-  return {
-    valid: o.valid,
-    actualVk: o.actual_vk,
-  };
-}
-
-export function fromClientIvcCheckPrecomputedVkResponse(o: ClientIvcCheckPrecomputedVkResponse): MsgpackClientIvcCheckPrecomputedVkResponse {
-  if (o.valid === undefined) { throw new Error("Expected valid in ClientIvcCheckPrecomputedVkResponse serialization"); }
-  if (o.actualVk === undefined) { throw new Error("Expected actualVk in ClientIvcCheckPrecomputedVkResponse serialization"); };
-  return {
-  valid: o.valid,
-  actual_vk: o.actualVk,
-  };
-}
-
-export function toClientIvcComputeIvcVk(o: MsgpackClientIvcComputeIvcVk): ClientIvcComputeIvcVk {
-  if (o.circuit === undefined) { throw new Error("Expected circuit in ClientIvcComputeIvcVk deserialization"); };
-  return {
-    circuit: toCircuitInputNoVK(o.circuit),
-  };
-}
-
-export function fromClientIvcComputeIvcVk(o: ClientIvcComputeIvcVk): MsgpackClientIvcComputeIvcVk {
-  if (o.circuit === undefined) { throw new Error("Expected circuit in ClientIvcComputeIvcVk serialization"); };
-  return {
-  circuit: fromCircuitInputNoVK(o.circuit),
-  };
-}
-
-export function toClientIvcComputeIvcVkResponse(o: MsgpackClientIvcComputeIvcVkResponse): ClientIvcComputeIvcVkResponse {
-  if (o.bytes === undefined) { throw new Error("Expected bytes in ClientIvcComputeIvcVkResponse deserialization"); };
-  return {
-    bytes: o.bytes,
-  };
-}
-
-export function fromClientIvcComputeIvcVkResponse(o: ClientIvcComputeIvcVkResponse): MsgpackClientIvcComputeIvcVkResponse {
-  if (o.bytes === undefined) { throw new Error("Expected bytes in ClientIvcComputeIvcVkResponse serialization"); };
-  return {
-  bytes: o.bytes,
-  };
-}
-
-export function toClientIvcComputeStandaloneVk(o: MsgpackClientIvcComputeStandaloneVk): ClientIvcComputeStandaloneVk {
-  if (o.circuit === undefined) { throw new Error("Expected circuit in ClientIvcComputeStandaloneVk deserialization"); };
-  return {
-    circuit: toCircuitInputNoVK(o.circuit),
-  };
-}
-
-export function fromClientIvcComputeStandaloneVk(o: ClientIvcComputeStandaloneVk): MsgpackClientIvcComputeStandaloneVk {
-  if (o.circuit === undefined) { throw new Error("Expected circuit in ClientIvcComputeStandaloneVk serialization"); };
-  return {
-  circuit: fromCircuitInputNoVK(o.circuit),
-  };
-}
-
-export function toClientIvcComputeStandaloneVkResponse(o: MsgpackClientIvcComputeStandaloneVkResponse): ClientIvcComputeStandaloneVkResponse {
-  if (o.bytes === undefined) { throw new Error("Expected bytes in ClientIvcComputeStandaloneVkResponse deserialization"); }
-  if (o.fields === undefined) { throw new Error("Expected fields in ClientIvcComputeStandaloneVkResponse deserialization"); };
-  return {
-    bytes: o.bytes,
-    fields: o.fields.map((v: any) => v),
-  };
-}
-
-export function fromClientIvcComputeStandaloneVkResponse(o: ClientIvcComputeStandaloneVkResponse): MsgpackClientIvcComputeStandaloneVkResponse {
-  if (o.bytes === undefined) { throw new Error("Expected bytes in ClientIvcComputeStandaloneVkResponse serialization"); }
-  if (o.fields === undefined) { throw new Error("Expected fields in ClientIvcComputeStandaloneVkResponse serialization"); };
-  return {
-  bytes: o.bytes,
-  fields: o.fields.map((v: any) => v),
-  };
-}
-
-export function toClientIvcLoad(o: MsgpackClientIvcLoad): ClientIvcLoad {
-  if (o.circuit === undefined) { throw new Error("Expected circuit in ClientIvcLoad deserialization"); };
-  return {
-    circuit: toCircuitInput(o.circuit),
-  };
-}
-
-export function fromClientIvcLoad(o: ClientIvcLoad): MsgpackClientIvcLoad {
-  if (o.circuit === undefined) { throw new Error("Expected circuit in ClientIvcLoad serialization"); };
-  return {
-  circuit: fromCircuitInput(o.circuit),
-  };
-}
-
-export function toClientIvcLoadResponse(o: MsgpackClientIvcLoadResponse): ClientIvcLoadResponse {
-  return {};
-}
-
-export function fromClientIvcLoadResponse(o: ClientIvcLoadResponse): MsgpackClientIvcLoadResponse {
-  return {};
-}
-
-export function toClientIVCProof(o: MsgpackClientIVCProof): ClientIVCProof {
-  if (o.mega_proof === undefined) { throw new Error("Expected mega_proof in ClientIVCProof deserialization"); }
-  if (o.goblin_proof === undefined) { throw new Error("Expected goblin_proof in ClientIVCProof deserialization"); };
-  return {
-    megaProof: o.mega_proof.map((v: any) => v),
-    goblinProof: toGoblinProof(o.goblin_proof),
-  };
-}
-
-export function fromClientIVCProof(o: ClientIVCProof): MsgpackClientIVCProof {
-  if (o.megaProof === undefined) { throw new Error("Expected megaProof in ClientIVCProof serialization"); }
-  if (o.goblinProof === undefined) { throw new Error("Expected goblinProof in ClientIVCProof serialization"); };
-  return {
-  mega_proof: o.megaProof.map((v: any) => v),
-  goblin_proof: fromGoblinProof(o.goblinProof),
-  };
-}
-
-export function toClientIvcProve(o: MsgpackClientIvcProve): ClientIvcProve {
-  return {};
-}
-
-export function fromClientIvcProve(o: ClientIvcProve): MsgpackClientIvcProve {
-  return {};
-}
-
-export function toClientIvcProveResponse(o: MsgpackClientIvcProveResponse): ClientIvcProveResponse {
-  if (o.proof === undefined) { throw new Error("Expected proof in ClientIvcProveResponse deserialization"); };
-  return {
-    proof: toClientIVCProof(o.proof),
-  };
-}
-
-export function fromClientIvcProveResponse(o: ClientIvcProveResponse): MsgpackClientIvcProveResponse {
-  if (o.proof === undefined) { throw new Error("Expected proof in ClientIvcProveResponse serialization"); };
-  return {
-  proof: fromClientIVCProof(o.proof),
-  };
-}
-
-export function toClientIvcStart(o: MsgpackClientIvcStart): ClientIvcStart {
-  if (o.num_circuits === undefined) { throw new Error("Expected num_circuits in ClientIvcStart deserialization"); };
-  return {
-    numCircuits: o.num_circuits,
-  };
-}
-
-export function fromClientIvcStart(o: ClientIvcStart): MsgpackClientIvcStart {
-  if (o.numCircuits === undefined) { throw new Error("Expected numCircuits in ClientIvcStart serialization"); };
-  return {
-  num_circuits: o.numCircuits,
-  };
-}
-
-export function toClientIvcStartResponse(o: MsgpackClientIvcStartResponse): ClientIvcStartResponse {
-  return {};
-}
-
-export function fromClientIvcStartResponse(o: ClientIvcStartResponse): MsgpackClientIvcStartResponse {
-  return {};
-}
-
-export function toClientIvcStats(o: MsgpackClientIvcStats): ClientIvcStats {
-  if (o.circuit === undefined) { throw new Error("Expected circuit in ClientIvcStats deserialization"); }
-  if (o.include_gates_per_opcode === undefined) { throw new Error("Expected include_gates_per_opcode in ClientIvcStats deserialization"); };
-  return {
-    circuit: toCircuitInputNoVK(o.circuit),
-    includeGatesPerOpcode: o.include_gates_per_opcode,
-  };
-}
-
-export function fromClientIvcStats(o: ClientIvcStats): MsgpackClientIvcStats {
-  if (o.circuit === undefined) { throw new Error("Expected circuit in ClientIvcStats serialization"); }
-  if (o.includeGatesPerOpcode === undefined) { throw new Error("Expected includeGatesPerOpcode in ClientIvcStats serialization"); };
-  return {
-  circuit: fromCircuitInputNoVK(o.circuit),
-  include_gates_per_opcode: o.includeGatesPerOpcode,
-  };
-}
-
-export function toClientIvcStatsResponse(o: MsgpackClientIvcStatsResponse): ClientIvcStatsResponse {
-  if (o.acir_opcodes === undefined) { throw new Error("Expected acir_opcodes in ClientIvcStatsResponse deserialization"); }
-  if (o.circuit_size === undefined) { throw new Error("Expected circuit_size in ClientIvcStatsResponse deserialization"); }
-  if (o.gates_per_opcode === undefined) { throw new Error("Expected gates_per_opcode in ClientIvcStatsResponse deserialization"); };
-  return {
-    acirOpcodes: o.acir_opcodes,
-    circuitSize: o.circuit_size,
-    gatesPerOpcode: o.gates_per_opcode.map((v: any) => v),
-  };
-}
-
-export function fromClientIvcStatsResponse(o: ClientIvcStatsResponse): MsgpackClientIvcStatsResponse {
-  if (o.acirOpcodes === undefined) { throw new Error("Expected acirOpcodes in ClientIvcStatsResponse serialization"); }
-  if (o.circuitSize === undefined) { throw new Error("Expected circuitSize in ClientIvcStatsResponse serialization"); }
-  if (o.gatesPerOpcode === undefined) { throw new Error("Expected gatesPerOpcode in ClientIvcStatsResponse serialization"); };
-  return {
-  acir_opcodes: o.acirOpcodes,
-  circuit_size: o.circuitSize,
-  gates_per_opcode: o.gatesPerOpcode.map((v: any) => v),
-  };
-}
-
-export function toClientIvcVerify(o: MsgpackClientIvcVerify): ClientIvcVerify {
-  if (o.proof === undefined) { throw new Error("Expected proof in ClientIvcVerify deserialization"); }
-  if (o.vk === undefined) { throw new Error("Expected vk in ClientIvcVerify deserialization"); };
-  return {
-    proof: toClientIVCProof(o.proof),
-    vk: o.vk,
-  };
-}
-
-export function fromClientIvcVerify(o: ClientIvcVerify): MsgpackClientIvcVerify {
-  if (o.proof === undefined) { throw new Error("Expected proof in ClientIvcVerify serialization"); }
-  if (o.vk === undefined) { throw new Error("Expected vk in ClientIvcVerify serialization"); };
-  return {
-  proof: fromClientIVCProof(o.proof),
-  vk: o.vk,
-  };
-}
-
-export function toClientIvcVerifyResponse(o: MsgpackClientIvcVerifyResponse): ClientIvcVerifyResponse {
-  if (o.valid === undefined) { throw new Error("Expected valid in ClientIvcVerifyResponse deserialization"); };
-  return {
-    valid: o.valid,
-  };
-}
-
-export function fromClientIvcVerifyResponse(o: ClientIvcVerifyResponse): MsgpackClientIvcVerifyResponse {
-  if (o.valid === undefined) { throw new Error("Expected valid in ClientIvcVerifyResponse serialization"); };
-  return {
-  valid: o.valid,
-  };
-}
-
-export function toECCVMProof(o: MsgpackECCVMProof): ECCVMProof {
-  if (o.pre_ipa_proof === undefined) { throw new Error("Expected pre_ipa_proof in ECCVMProof deserialization"); }
-  if (o.ipa_proof === undefined) { throw new Error("Expected ipa_proof in ECCVMProof deserialization"); };
-  return {
-    preIpaProof: o.pre_ipa_proof.map((v: any) => v),
-    ipaProof: o.ipa_proof.map((v: any) => v),
-  };
-}
-
-export function fromECCVMProof(o: ECCVMProof): MsgpackECCVMProof {
-  if (o.preIpaProof === undefined) { throw new Error("Expected preIpaProof in ECCVMProof serialization"); }
-  if (o.ipaProof === undefined) { throw new Error("Expected ipaProof in ECCVMProof serialization"); };
-  return {
-  pre_ipa_proof: o.preIpaProof.map((v: any) => v),
-  ipa_proof: o.ipaProof.map((v: any) => v),
-  };
-}
-
 export function toEcdsaSecp256k1ComputePublicKey(o: MsgpackEcdsaSecp256k1ComputePublicKey): EcdsaSecp256k1ComputePublicKey {
   if (o.private_key === undefined) { throw new Error("Expected private_key in EcdsaSecp256k1ComputePublicKey deserialization"); };
   return {
@@ -2702,14 +3109,14 @@ export function fromEcdsaSecp256k1ComputePublicKey(o: EcdsaSecp256k1ComputePubli
 export function toEcdsaSecp256k1ComputePublicKeyResponse(o: MsgpackEcdsaSecp256k1ComputePublicKeyResponse): EcdsaSecp256k1ComputePublicKeyResponse {
   if (o.public_key === undefined) { throw new Error("Expected public_key in EcdsaSecp256k1ComputePublicKeyResponse deserialization"); };
   return {
-    publicKey: toAffineElement(o.public_key),
+    publicKey: toSecp256k1Point(o.public_key),
   };
 }
 
 export function fromEcdsaSecp256k1ComputePublicKeyResponse(o: EcdsaSecp256k1ComputePublicKeyResponse): MsgpackEcdsaSecp256k1ComputePublicKeyResponse {
   if (o.publicKey === undefined) { throw new Error("Expected publicKey in EcdsaSecp256k1ComputePublicKeyResponse serialization"); };
   return {
-  public_key: fromAffineElement(o.publicKey),
+  public_key: fromSecp256k1Point(o.publicKey),
   };
 }
 
@@ -2782,14 +3189,14 @@ export function fromEcdsaSecp256k1RecoverPublicKey(o: EcdsaSecp256k1RecoverPubli
 export function toEcdsaSecp256k1RecoverPublicKeyResponse(o: MsgpackEcdsaSecp256k1RecoverPublicKeyResponse): EcdsaSecp256k1RecoverPublicKeyResponse {
   if (o.public_key === undefined) { throw new Error("Expected public_key in EcdsaSecp256k1RecoverPublicKeyResponse deserialization"); };
   return {
-    publicKey: toAffineElement(o.public_key),
+    publicKey: toSecp256k1Point(o.public_key),
   };
 }
 
 export function fromEcdsaSecp256k1RecoverPublicKeyResponse(o: EcdsaSecp256k1RecoverPublicKeyResponse): MsgpackEcdsaSecp256k1RecoverPublicKeyResponse {
   if (o.publicKey === undefined) { throw new Error("Expected publicKey in EcdsaSecp256k1RecoverPublicKeyResponse serialization"); };
   return {
-  public_key: fromAffineElement(o.publicKey),
+  public_key: fromSecp256k1Point(o.publicKey),
   };
 }
 
@@ -2801,7 +3208,7 @@ export function toEcdsaSecp256k1VerifySignature(o: MsgpackEcdsaSecp256k1VerifySi
   if (o.v === undefined) { throw new Error("Expected v in EcdsaSecp256k1VerifySignature deserialization"); };
   return {
     message: o.message,
-    publicKey: toAffineElement(o.public_key),
+    publicKey: toSecp256k1Point(o.public_key),
     r: o.r,
     s: o.s,
     v: o.v,
@@ -2816,7 +3223,7 @@ export function fromEcdsaSecp256k1VerifySignature(o: EcdsaSecp256k1VerifySignatu
   if (o.v === undefined) { throw new Error("Expected v in EcdsaSecp256k1VerifySignature serialization"); };
   return {
   message: o.message,
-  public_key: fromAffineElement(o.publicKey),
+  public_key: fromSecp256k1Point(o.publicKey),
   r: o.r,
   s: o.s,
   v: o.v,
@@ -2854,14 +3261,14 @@ export function fromEcdsaSecp256r1ComputePublicKey(o: EcdsaSecp256r1ComputePubli
 export function toEcdsaSecp256r1ComputePublicKeyResponse(o: MsgpackEcdsaSecp256r1ComputePublicKeyResponse): EcdsaSecp256r1ComputePublicKeyResponse {
   if (o.public_key === undefined) { throw new Error("Expected public_key in EcdsaSecp256r1ComputePublicKeyResponse deserialization"); };
   return {
-    publicKey: toAffineElement(o.public_key),
+    publicKey: toSecp256r1Point(o.public_key),
   };
 }
 
 export function fromEcdsaSecp256r1ComputePublicKeyResponse(o: EcdsaSecp256r1ComputePublicKeyResponse): MsgpackEcdsaSecp256r1ComputePublicKeyResponse {
   if (o.publicKey === undefined) { throw new Error("Expected publicKey in EcdsaSecp256r1ComputePublicKeyResponse serialization"); };
   return {
-  public_key: fromAffineElement(o.publicKey),
+  public_key: fromSecp256r1Point(o.publicKey),
   };
 }
 
@@ -2934,14 +3341,14 @@ export function fromEcdsaSecp256r1RecoverPublicKey(o: EcdsaSecp256r1RecoverPubli
 export function toEcdsaSecp256r1RecoverPublicKeyResponse(o: MsgpackEcdsaSecp256r1RecoverPublicKeyResponse): EcdsaSecp256r1RecoverPublicKeyResponse {
   if (o.public_key === undefined) { throw new Error("Expected public_key in EcdsaSecp256r1RecoverPublicKeyResponse deserialization"); };
   return {
-    publicKey: toAffineElement(o.public_key),
+    publicKey: toSecp256r1Point(o.public_key),
   };
 }
 
 export function fromEcdsaSecp256r1RecoverPublicKeyResponse(o: EcdsaSecp256r1RecoverPublicKeyResponse): MsgpackEcdsaSecp256r1RecoverPublicKeyResponse {
   if (o.publicKey === undefined) { throw new Error("Expected publicKey in EcdsaSecp256r1RecoverPublicKeyResponse serialization"); };
   return {
-  public_key: fromAffineElement(o.publicKey),
+  public_key: fromSecp256r1Point(o.publicKey),
   };
 }
 
@@ -2953,7 +3360,7 @@ export function toEcdsaSecp256r1VerifySignature(o: MsgpackEcdsaSecp256r1VerifySi
   if (o.v === undefined) { throw new Error("Expected v in EcdsaSecp256r1VerifySignature deserialization"); };
   return {
     message: o.message,
-    publicKey: toAffineElement(o.public_key),
+    publicKey: toSecp256r1Point(o.public_key),
     r: o.r,
     s: o.s,
     v: o.v,
@@ -2968,7 +3375,7 @@ export function fromEcdsaSecp256r1VerifySignature(o: EcdsaSecp256r1VerifySignatu
   if (o.v === undefined) { throw new Error("Expected v in EcdsaSecp256r1VerifySignature serialization"); };
   return {
   message: o.message,
-  public_key: fromAffineElement(o.publicKey),
+  public_key: fromSecp256r1Point(o.publicKey),
   r: o.r,
   s: o.s,
   v: o.v,
@@ -2989,13 +3396,29 @@ export function fromEcdsaSecp256r1VerifySignatureResponse(o: EcdsaSecp256r1Verif
   };
 }
 
+export function toErrorResponse(o: MsgpackErrorResponse): ErrorResponse {
+  if (o.message === undefined) { throw new Error("Expected message in ErrorResponse deserialization"); };
+  return {
+    message: o.message,
+  };
+}
+
+export function fromErrorResponse(o: ErrorResponse): MsgpackErrorResponse {
+  if (o.message === undefined) { throw new Error("Expected message in ErrorResponse serialization"); };
+  return {
+  message: o.message,
+  };
+}
+
 export function toGoblinProof(o: MsgpackGoblinProof): GoblinProof {
   if (o.merge_proof === undefined) { throw new Error("Expected merge_proof in GoblinProof deserialization"); }
   if (o.eccvm_proof === undefined) { throw new Error("Expected eccvm_proof in GoblinProof deserialization"); }
+  if (o.ipa_proof === undefined) { throw new Error("Expected ipa_proof in GoblinProof deserialization"); }
   if (o.translator_proof === undefined) { throw new Error("Expected translator_proof in GoblinProof deserialization"); };
   return {
     mergeProof: o.merge_proof.map((v: any) => v),
-    eccvmProof: toECCVMProof(o.eccvm_proof),
+    eccvmProof: o.eccvm_proof.map((v: any) => v),
+    ipaProof: o.ipa_proof.map((v: any) => v),
     translatorProof: o.translator_proof.map((v: any) => v),
   };
 }
@@ -3003,10 +3426,12 @@ export function toGoblinProof(o: MsgpackGoblinProof): GoblinProof {
 export function fromGoblinProof(o: GoblinProof): MsgpackGoblinProof {
   if (o.mergeProof === undefined) { throw new Error("Expected mergeProof in GoblinProof serialization"); }
   if (o.eccvmProof === undefined) { throw new Error("Expected eccvmProof in GoblinProof serialization"); }
+  if (o.ipaProof === undefined) { throw new Error("Expected ipaProof in GoblinProof serialization"); }
   if (o.translatorProof === undefined) { throw new Error("Expected translatorProof in GoblinProof serialization"); };
   return {
   merge_proof: o.mergeProof.map((v: any) => v),
-  eccvm_proof: fromECCVMProof(o.eccvmProof),
+  eccvm_proof: o.eccvmProof.map((v: any) => v),
+  ipa_proof: o.ipaProof.map((v: any) => v),
   translator_proof: o.translatorProof.map((v: any) => v),
   };
 }
@@ -3015,8 +3440,8 @@ export function toGrumpkinAdd(o: MsgpackGrumpkinAdd): GrumpkinAdd {
   if (o.point_a === undefined) { throw new Error("Expected point_a in GrumpkinAdd deserialization"); }
   if (o.point_b === undefined) { throw new Error("Expected point_b in GrumpkinAdd deserialization"); };
   return {
-    pointA: toAffineElement(o.point_a),
-    pointB: toAffineElement(o.point_b),
+    pointA: toGrumpkinPoint(o.point_a),
+    pointB: toGrumpkinPoint(o.point_b),
   };
 }
 
@@ -3024,22 +3449,22 @@ export function fromGrumpkinAdd(o: GrumpkinAdd): MsgpackGrumpkinAdd {
   if (o.pointA === undefined) { throw new Error("Expected pointA in GrumpkinAdd serialization"); }
   if (o.pointB === undefined) { throw new Error("Expected pointB in GrumpkinAdd serialization"); };
   return {
-  point_a: fromAffineElement(o.pointA),
-  point_b: fromAffineElement(o.pointB),
+  point_a: fromGrumpkinPoint(o.pointA),
+  point_b: fromGrumpkinPoint(o.pointB),
   };
 }
 
 export function toGrumpkinAddResponse(o: MsgpackGrumpkinAddResponse): GrumpkinAddResponse {
   if (o.point === undefined) { throw new Error("Expected point in GrumpkinAddResponse deserialization"); };
   return {
-    point: toAffineElement(o.point),
+    point: toGrumpkinPoint(o.point),
   };
 }
 
 export function fromGrumpkinAddResponse(o: GrumpkinAddResponse): MsgpackGrumpkinAddResponse {
   if (o.point === undefined) { throw new Error("Expected point in GrumpkinAddResponse serialization"); };
   return {
-  point: fromAffineElement(o.point),
+  point: fromGrumpkinPoint(o.point),
   };
 }
 
@@ -3107,7 +3532,7 @@ export function toGrumpkinMul(o: MsgpackGrumpkinMul): GrumpkinMul {
   if (o.point === undefined) { throw new Error("Expected point in GrumpkinMul deserialization"); }
   if (o.scalar === undefined) { throw new Error("Expected scalar in GrumpkinMul deserialization"); };
   return {
-    point: toAffineElement(o.point),
+    point: toGrumpkinPoint(o.point),
     scalar: o.scalar,
   };
 }
@@ -3116,7 +3541,7 @@ export function fromGrumpkinMul(o: GrumpkinMul): MsgpackGrumpkinMul {
   if (o.point === undefined) { throw new Error("Expected point in GrumpkinMul serialization"); }
   if (o.scalar === undefined) { throw new Error("Expected scalar in GrumpkinMul serialization"); };
   return {
-  point: fromAffineElement(o.point),
+  point: fromGrumpkinPoint(o.point),
   scalar: o.scalar,
   };
 }
@@ -3124,14 +3549,32 @@ export function fromGrumpkinMul(o: GrumpkinMul): MsgpackGrumpkinMul {
 export function toGrumpkinMulResponse(o: MsgpackGrumpkinMulResponse): GrumpkinMulResponse {
   if (o.point === undefined) { throw new Error("Expected point in GrumpkinMulResponse deserialization"); };
   return {
-    point: toAffineElement(o.point),
+    point: toGrumpkinPoint(o.point),
   };
 }
 
 export function fromGrumpkinMulResponse(o: GrumpkinMulResponse): MsgpackGrumpkinMulResponse {
   if (o.point === undefined) { throw new Error("Expected point in GrumpkinMulResponse serialization"); };
   return {
-  point: fromAffineElement(o.point),
+  point: fromGrumpkinPoint(o.point),
+  };
+}
+
+export function toGrumpkinPoint(o: MsgpackGrumpkinPoint): GrumpkinPoint {
+  if (o.x === undefined) { throw new Error("Expected x in GrumpkinPoint deserialization"); }
+  if (o.y === undefined) { throw new Error("Expected y in GrumpkinPoint deserialization"); };
+  return {
+    x: o.x,
+    y: o.y,
+  };
+}
+
+export function fromGrumpkinPoint(o: GrumpkinPoint): MsgpackGrumpkinPoint {
+  if (o.x === undefined) { throw new Error("Expected x in GrumpkinPoint serialization"); }
+  if (o.y === undefined) { throw new Error("Expected y in GrumpkinPoint serialization"); };
+  return {
+  x: o.x,
+  y: o.y,
   };
 }
 
@@ -3212,14 +3655,14 @@ export function fromPedersenCommit(o: PedersenCommit): MsgpackPedersenCommit {
 export function toPedersenCommitResponse(o: MsgpackPedersenCommitResponse): PedersenCommitResponse {
   if (o.point === undefined) { throw new Error("Expected point in PedersenCommitResponse deserialization"); };
   return {
-    point: toAffineElement(o.point),
+    point: toGrumpkinPoint(o.point),
   };
 }
 
 export function fromPedersenCommitResponse(o: PedersenCommitResponse): MsgpackPedersenCommitResponse {
   if (o.point === undefined) { throw new Error("Expected point in PedersenCommitResponse serialization"); };
   return {
-  point: fromAffineElement(o.point),
+  point: fromGrumpkinPoint(o.point),
   };
 }
 
@@ -3414,14 +3857,14 @@ export function fromSchnorrComputePublicKey(o: SchnorrComputePublicKey): Msgpack
 export function toSchnorrComputePublicKeyResponse(o: MsgpackSchnorrComputePublicKeyResponse): SchnorrComputePublicKeyResponse {
   if (o.public_key === undefined) { throw new Error("Expected public_key in SchnorrComputePublicKeyResponse deserialization"); };
   return {
-    publicKey: toAffineElement(o.public_key),
+    publicKey: toGrumpkinPoint(o.public_key),
   };
 }
 
 export function fromSchnorrComputePublicKeyResponse(o: SchnorrComputePublicKeyResponse): MsgpackSchnorrComputePublicKeyResponse {
   if (o.publicKey === undefined) { throw new Error("Expected publicKey in SchnorrComputePublicKeyResponse serialization"); };
   return {
-  public_key: fromAffineElement(o.publicKey),
+  public_key: fromGrumpkinPoint(o.publicKey),
   };
 }
 
@@ -3468,7 +3911,7 @@ export function toSchnorrVerifySignature(o: MsgpackSchnorrVerifySignature): Schn
   if (o.e === undefined) { throw new Error("Expected e in SchnorrVerifySignature deserialization"); };
   return {
     message: o.message,
-    publicKey: toAffineElement(o.public_key),
+    publicKey: toGrumpkinPoint(o.public_key),
     s: o.s,
     e: o.e,
   };
@@ -3481,7 +3924,7 @@ export function fromSchnorrVerifySignature(o: SchnorrVerifySignature): MsgpackSc
   if (o.e === undefined) { throw new Error("Expected e in SchnorrVerifySignature serialization"); };
   return {
   message: o.message,
-  public_key: fromAffineElement(o.publicKey),
+  public_key: fromGrumpkinPoint(o.publicKey),
   s: o.s,
   e: o.e,
   };
@@ -3533,7 +3976,7 @@ export function toSecp256k1Mul(o: MsgpackSecp256k1Mul): Secp256k1Mul {
   if (o.point === undefined) { throw new Error("Expected point in Secp256k1Mul deserialization"); }
   if (o.scalar === undefined) { throw new Error("Expected scalar in Secp256k1Mul deserialization"); };
   return {
-    point: toAffineElement(o.point),
+    point: toSecp256k1Point(o.point),
     scalar: o.scalar,
   };
 }
@@ -3542,7 +3985,7 @@ export function fromSecp256k1Mul(o: Secp256k1Mul): MsgpackSecp256k1Mul {
   if (o.point === undefined) { throw new Error("Expected point in Secp256k1Mul serialization"); }
   if (o.scalar === undefined) { throw new Error("Expected scalar in Secp256k1Mul serialization"); };
   return {
-  point: fromAffineElement(o.point),
+  point: fromSecp256k1Point(o.point),
   scalar: o.scalar,
   };
 }
@@ -3550,14 +3993,32 @@ export function fromSecp256k1Mul(o: Secp256k1Mul): MsgpackSecp256k1Mul {
 export function toSecp256k1MulResponse(o: MsgpackSecp256k1MulResponse): Secp256k1MulResponse {
   if (o.point === undefined) { throw new Error("Expected point in Secp256k1MulResponse deserialization"); };
   return {
-    point: toAffineElement(o.point),
+    point: toSecp256k1Point(o.point),
   };
 }
 
 export function fromSecp256k1MulResponse(o: Secp256k1MulResponse): MsgpackSecp256k1MulResponse {
   if (o.point === undefined) { throw new Error("Expected point in Secp256k1MulResponse serialization"); };
   return {
-  point: fromAffineElement(o.point),
+  point: fromSecp256k1Point(o.point),
+  };
+}
+
+export function toSecp256k1Point(o: MsgpackSecp256k1Point): Secp256k1Point {
+  if (o.x === undefined) { throw new Error("Expected x in Secp256k1Point deserialization"); }
+  if (o.y === undefined) { throw new Error("Expected y in Secp256k1Point deserialization"); };
+  return {
+    x: o.x,
+    y: o.y,
+  };
+}
+
+export function fromSecp256k1Point(o: Secp256k1Point): MsgpackSecp256k1Point {
+  if (o.x === undefined) { throw new Error("Expected x in Secp256k1Point serialization"); }
+  if (o.y === undefined) { throw new Error("Expected y in Secp256k1Point serialization"); };
+  return {
+  x: o.x,
+  y: o.y,
   };
 }
 
@@ -3589,6 +4050,24 @@ export function fromSecp256k1Reduce512Response(o: Secp256k1Reduce512Response): M
   };
 }
 
+export function toSecp256r1Point(o: MsgpackSecp256r1Point): Secp256r1Point {
+  if (o.x === undefined) { throw new Error("Expected x in Secp256r1Point deserialization"); }
+  if (o.y === undefined) { throw new Error("Expected y in Secp256r1Point deserialization"); };
+  return {
+    x: o.x,
+    y: o.y,
+  };
+}
+
+export function fromSecp256r1Point(o: Secp256r1Point): MsgpackSecp256r1Point {
+  if (o.x === undefined) { throw new Error("Expected x in Secp256r1Point serialization"); }
+  if (o.y === undefined) { throw new Error("Expected y in Secp256r1Point serialization"); };
+  return {
+  x: o.x,
+  y: o.y,
+  };
+}
+
 export function toShutdown(o: MsgpackShutdown): Shutdown {
   return {};
 }
@@ -3708,18 +4187,18 @@ export interface BbApiBase {
   circuitComputeVk(command: CircuitComputeVk): Promise<CircuitComputeVkResponse>;
   circuitStats(command: CircuitStats): Promise<CircuitInfoResponse>;
   circuitVerify(command: CircuitVerify): Promise<CircuitVerifyResponse>;
-  clientIvcComputeStandaloneVk(command: ClientIvcComputeStandaloneVk): Promise<ClientIvcComputeStandaloneVkResponse>;
-  clientIvcComputeIvcVk(command: ClientIvcComputeIvcVk): Promise<ClientIvcComputeIvcVkResponse>;
-  clientIvcStart(command: ClientIvcStart): Promise<ClientIvcStartResponse>;
-  clientIvcLoad(command: ClientIvcLoad): Promise<ClientIvcLoadResponse>;
-  clientIvcAccumulate(command: ClientIvcAccumulate): Promise<ClientIvcAccumulateResponse>;
-  clientIvcProve(command: ClientIvcProve): Promise<ClientIvcProveResponse>;
-  clientIvcVerify(command: ClientIvcVerify): Promise<ClientIvcVerifyResponse>;
+  chonkComputeStandaloneVk(command: ChonkComputeStandaloneVk): Promise<ChonkComputeStandaloneVkResponse>;
+  chonkComputeIvcVk(command: ChonkComputeIvcVk): Promise<ChonkComputeIvcVkResponse>;
+  chonkStart(command: ChonkStart): Promise<ChonkStartResponse>;
+  chonkLoad(command: ChonkLoad): Promise<ChonkLoadResponse>;
+  chonkAccumulate(command: ChonkAccumulate): Promise<ChonkAccumulateResponse>;
+  chonkProve(command: ChonkProve): Promise<ChonkProveResponse>;
+  chonkVerify(command: ChonkVerify): Promise<ChonkVerifyResponse>;
   vkAsFields(command: VkAsFields): Promise<VkAsFieldsResponse>;
   megaVkAsFields(command: MegaVkAsFields): Promise<MegaVkAsFieldsResponse>;
   circuitWriteSolidityVerifier(command: CircuitWriteSolidityVerifier): Promise<CircuitWriteSolidityVerifierResponse>;
-  clientIvcCheckPrecomputedVk(command: ClientIvcCheckPrecomputedVk): Promise<ClientIvcCheckPrecomputedVkResponse>;
-  clientIvcStats(command: ClientIvcStats): Promise<ClientIvcStatsResponse>;
+  chonkCheckPrecomputedVk(command: ChonkCheckPrecomputedVk): Promise<ChonkCheckPrecomputedVkResponse>;
+  chonkStats(command: ChonkStats): Promise<ChonkStatsResponse>;
   poseidon2Hash(command: Poseidon2Hash): Promise<Poseidon2HashResponse>;
   poseidon2Permutation(command: Poseidon2Permutation): Promise<Poseidon2PermutationResponse>;
   poseidon2HashAccumulate(command: Poseidon2HashAccumulate): Promise<Poseidon2HashAccumulateResponse>;
@@ -3739,6 +4218,11 @@ export interface BbApiBase {
   secp256k1GetRandomFr(command: Secp256k1GetRandomFr): Promise<Secp256k1GetRandomFrResponse>;
   secp256k1Reduce512(command: Secp256k1Reduce512): Promise<Secp256k1Reduce512Response>;
   bn254FrSqrt(command: Bn254FrSqrt): Promise<Bn254FrSqrtResponse>;
+  bn254FqSqrt(command: Bn254FqSqrt): Promise<Bn254FqSqrtResponse>;
+  bn254G1Mul(command: Bn254G1Mul): Promise<Bn254G1MulResponse>;
+  bn254G2Mul(command: Bn254G2Mul): Promise<Bn254G2MulResponse>;
+  bn254G1IsOnCurve(command: Bn254G1IsOnCurve): Promise<Bn254G1IsOnCurveResponse>;
+  bn254G1FromCompressed(command: Bn254G1FromCompressed): Promise<Bn254G1FromCompressedResponse>;
   schnorrComputePublicKey(command: SchnorrComputePublicKey): Promise<SchnorrComputePublicKeyResponse>;
   schnorrConstructSignature(command: SchnorrConstructSignature): Promise<SchnorrConstructSignatureResponse>;
   schnorrVerifySignature(command: SchnorrVerifySignature): Promise<SchnorrVerifySignatureResponse>;