@aztec/stdlib 4.0.0-nightly.20250907 → 4.0.0-nightly.20260107

package/src/tx/in_tx.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+
+import { type InBlock, inBlockSchema, randomInBlock } from '../block/in_block.js';
+import { TxHash } from './tx_hash.js';
+
+export type InTx = InBlock & {
+  txHash: TxHash;
+};
+
+export function randomInTx(): InTx {
+  return {
+    ...randomInBlock(),
+    txHash: TxHash.random(),
+  };
+}
+
+export function inTxSchema() {
+  return z.intersection(
+    inBlockSchema(),
+    z.object({
+      txHash: TxHash.schema,
+    }),
+  );
+}

package/src/tx/index.ts

@@ -6,11 +6,11 @@ export * from './state_reference.js';
 export * from './partial_state_reference.js';
 export * from './function_data.js';
 export * from './tree_snapshots.js';
+export * from './private_tx_constant_data.js';
 export * from './tx_constant_data.js';
 export * from './tx_context.js';
 export * from './tx_request.js';
 export * from './private_execution_result.js';
-export * from './proposed_block_header.js';
 export * from './public_call_request_with_calldata.js';
 export * from './tx_hash.js';
 export * from './tx_receipt.js';
@@ -30,3 +30,6 @@ export * from './hashed_values.js';
 export * from './indexed_tx_effect.js';
 export * from './offchain_effect.js';
 export * from './profiling.js';
+export * from './protocol_contracts.js';
+export * from './execution_payload.js';
+export * from './in_tx.js';

package/src/tx/indexed_tx_effect.ts

@@ -1,19 +1,20 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { L2BlockHash } from '../block/block_hash.js';
-import { type InBlock, inBlockSchemaFor, randomInBlock } from '../block/in_block.js';
+import { type DataInBlock, dataInBlockSchemaFor, randomDataInBlock } from '../block/in_block.js';
 import { TxEffect } from './tx_effect.js';
 
-export type IndexedTxEffect = InBlock<TxEffect> & { txIndexInBlock: number };
+export type IndexedTxEffect = DataInBlock<TxEffect> & { txIndexInBlock: number };
 
 export function indexedTxSchema() {
-  return inBlockSchemaFor(TxEffect.schema).extend({ txIndexInBlock: schemas.Integer });
+  return dataInBlockSchemaFor(TxEffect.schema).extend({ txIndexInBlock: schemas.Integer });
 }
 
 export async function randomIndexedTxEffect(): Promise<IndexedTxEffect> {
   return {
-    ...randomInBlock(await TxEffect.random()),
+    ...randomDataInBlock(await TxEffect.random({ numNullifiers: 1 + Math.floor(Math.random() * 64) })),
     txIndexInBlock: Math.floor(Math.random() * 1000),
   };
 }
@@ -26,7 +27,7 @@ export function deserializeIndexedTxEffect(buffer: Buffer): IndexedTxEffect {
   const reader = BufferReader.asReader(buffer);
 
   const l2BlockHash = reader.readObject(L2BlockHash);
-  const l2BlockNumber = reader.readNumber();
+  const l2BlockNumber = BlockNumber(reader.readNumber());
   const txIndexInBlock = reader.readNumber();
   const data = reader.readObject(TxEffect);
 

package/src/tx/offchain_effect.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 
 import type { AztecAddress } from '../aztec-address/index.js';
 

package/src/tx/partial_state_reference.ts

@@ -1,7 +1,7 @@
 import { PARTIAL_STATE_REFERENCE_LENGTH } from '@aztec/constants';
-import type { ViemPartialStateReference } from '@aztec/ethereum';
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
@@ -37,6 +37,14 @@ export class PartialStateReference {
     return this.noteHashTree.getSize() + this.nullifierTree.getSize() + this.publicDataTree.getSize();
   }
 
+  static getFields(fields: FieldsOf<PartialStateReference>) {
+    return [fields.noteHashTree, fields.nullifierTree, fields.publicDataTree] as const;
+  }
+
+  static from(fields: FieldsOf<PartialStateReference>) {
+    return new PartialStateReference(...PartialStateReference.getFields(fields));
+  }
+
   static fromBuffer(buffer: Buffer | BufferReader): PartialStateReference {
     const reader = BufferReader.asReader(buffer);
     return new PartialStateReference(
@@ -56,22 +64,14 @@ export class PartialStateReference {
     return new PartialStateReference(noteHashTree, nullifierTree, publicDataTree);
   }
 
-  static fromViem(stateReference: ViemPartialStateReference) {
+  static random(): PartialStateReference {
     return new PartialStateReference(
-      AppendOnlyTreeSnapshot.fromViem(stateReference.noteHashTree),
-      AppendOnlyTreeSnapshot.fromViem(stateReference.nullifierTree),
-      AppendOnlyTreeSnapshot.fromViem(stateReference.publicDataTree),
+      AppendOnlyTreeSnapshot.random(),
+      AppendOnlyTreeSnapshot.random(),
+      AppendOnlyTreeSnapshot.random(),
     );
   }
 
-  toViem(): ViemPartialStateReference {
-    return {
-      noteHashTree: this.noteHashTree.toViem(),
-      nullifierTree: this.nullifierTree.toViem(),
-      publicDataTree: this.publicDataTree.toViem(),
-    };
-  }
-
   toAbi(): [
     ReturnType<AppendOnlyTreeSnapshot['toAbi']>,
     ReturnType<AppendOnlyTreeSnapshot['toAbi']>,

package/src/tx/private_execution_result.ts

@@ -1,6 +1,7 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
 import { timesParallel } from '@aztec/foundation/collection';
-import { randomBytes, randomInt } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { randomBytes, randomInt } from '@aztec/foundation/crypto/random';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
@@ -10,9 +11,9 @@ import { PrivateCircuitPublicInputs } from '../kernel/private_circuit_public_inp
 import type { IsEmpty } from '../kernel/utils/interfaces.js';
 import { sortByCounter } from '../kernel/utils/order_and_comparison.js';
 import { ContractClassLog, ContractClassLogFields } from '../logs/contract_class_log.js';
+import { type PreTag, PreTagSchema } from '../logs/pre_tag.js';
 import { Note } from '../note/note.js';
 import { type ZodFor, mapSchema, schemas } from '../schemas/index.js';
-import type { UInt32 } from '../types/index.js';
 import { HashedValues } from './hashed_values.js';
 import type { OffchainEffect } from './offchain_effect.js';
 
@@ -25,6 +26,8 @@ export class NoteAndSlot {
     public note: Note,
     /** The storage slot of the note. */
     public storageSlot: Fr,
+    /** The randomness injected to the note. */
+    public randomness: Fr,
     /** The note type identifier. */
     public noteTypeId: NoteSelector,
   ) {}
@@ -34,17 +37,18 @@ export class NoteAndSlot {
       .object({
         note: Note.schema,
         storageSlot: schemas.Fr,
+        randomness: schemas.Fr,
         noteTypeId: schemas.NoteSelector,
       })
       .transform(NoteAndSlot.from);
   }
 
   static from(fields: FieldsOf<NoteAndSlot>) {
-    return new NoteAndSlot(fields.note, fields.storageSlot, fields.noteTypeId);
+    return new NoteAndSlot(fields.note, fields.storageSlot, fields.randomness, fields.noteTypeId);
   }
 
   static random() {
-    return new NoteAndSlot(Note.random(), Fr.random(), NoteSelector.random());
+    return new NoteAndSlot(Note.random(), Fr.random(), Fr.random(), NoteSelector.random());
   }
 }
 
@@ -103,10 +107,10 @@ export class PrivateExecutionResult {
   }
 
   /**
-   * The block number that this execution was simulated with.
+   * The anchor block number that this execution was simulated with.
    */
-  getSimulationBlockNumber(): UInt32 {
-    return this.entrypoint.publicInputs.historicalHeader.globalVariables.blockNumber;
+  getSimulationAnchorBlockNumber(): BlockNumber {
+    return this.entrypoint.publicInputs.anchorBlockHeader.globalVariables.blockNumber;
   }
 }
 
@@ -135,6 +139,8 @@ export class PrivateCallExecutionResult {
     public returnValues: Fr[],
     /** The offchain effects emitted during execution of this function call via the `emit_offchain_effect` oracle. */
     public offchainEffects: { data: Fr[] }[],
+    /** The pre-tags used in this tx to compute tags for private logs */
+    public preTags: PreTag[],
     /** The nested executions. */
     public nestedExecutionResults: PrivateCallExecutionResult[],
     /**
@@ -158,6 +164,7 @@ export class PrivateCallExecutionResult {
         noteHashNullifierCounterMap: mapSchema(z.coerce.number(), z.number()),
         returnValues: z.array(schemas.Fr),
         offchainEffects: z.array(z.object({ data: z.array(schemas.Fr) })),
+        preTags: z.array(PreTagSchema),
         nestedExecutionResults: z.array(z.lazy(() => PrivateCallExecutionResult.schema)),
         contractClassLogs: z.array(CountedContractClassLog.schema),
       })
@@ -175,6 +182,7 @@ export class PrivateCallExecutionResult {
       fields.noteHashNullifierCounterMap,
       fields.returnValues,
       fields.offchainEffects,
+      fields.preTags,
       fields.nestedExecutionResults,
       fields.contractClassLogs,
     );
@@ -195,6 +203,7 @@ export class PrivateCallExecutionResult {
           data: [Fr.random()],
         },
       ],
+      [],
       await timesParallel(nested, () => PrivateCallExecutionResult.random(0)),
       [new CountedContractClassLog(await ContractClassLog.random(), randomInt(10))],
     );

package/src/tx/private_tx_constant_data.ts

@@ -0,0 +1,94 @@
+import { TX_CONSTANT_DATA_LENGTH } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { BlockHeader } from './block_header.js';
+import { ProtocolContracts } from './protocol_contracts.js';
+import { TxContext } from './tx_context.js';
+
+/**
+ * Data that is constant/not modified by neither of the kernels.
+ */
+export class PrivateTxConstantData {
+  constructor(
+    /** Header of a block whose state is used during execution (not the block the transaction is included in). */
+    public anchorBlockHeader: BlockHeader,
+    /**
+     * Context of the transaction.
+     *
+     * Note: `chainId` and `version` in txContext are not redundant to the values in
+     * self.anchor_block_header.global_variables because they can be different in case of a protocol upgrade. In such
+     * a situation we could be using header from a block before the upgrade took place but be using the updated
+     * protocol to execute and prove the transaction.
+     */
+    public txContext: TxContext,
+    /**
+     * Root of the vk tree for the protocol circuits.
+     */
+    public vkTreeRoot: Fr,
+    /**
+     * List of protocol contracts.
+     */
+    public protocolContracts: ProtocolContracts,
+  ) {}
+
+  static from(fields: FieldsOf<PrivateTxConstantData>) {
+    return new PrivateTxConstantData(...PrivateTxConstantData.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<PrivateTxConstantData>) {
+    return [fields.anchorBlockHeader, fields.txContext, fields.vkTreeRoot, fields.protocolContracts] as const;
+  }
+
+  static fromFields(fields: Fr[] | FieldReader): PrivateTxConstantData {
+    const reader = FieldReader.asReader(fields);
+    return new PrivateTxConstantData(
+      reader.readObject(BlockHeader),
+      reader.readObject(TxContext),
+      reader.readField(),
+      reader.readObject(ProtocolContracts),
+    );
+  }
+
+  toFields(): Fr[] {
+    const fields = serializeToFields(...PrivateTxConstantData.getFields(this));
+    if (fields.length !== TX_CONSTANT_DATA_LENGTH) {
+      throw new Error(
+        `Invalid number of fields for PrivateTxConstantData. Expected ${TX_CONSTANT_DATA_LENGTH}, got ${fields.length}`,
+      );
+    }
+    return fields;
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): PrivateTxConstantData {
+    const reader = BufferReader.asReader(buffer);
+    return new PrivateTxConstantData(
+      reader.readObject(BlockHeader),
+      reader.readObject(TxContext),
+      Fr.fromBuffer(reader),
+      reader.readObject(ProtocolContracts),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...PrivateTxConstantData.getFields(this));
+  }
+
+  static empty() {
+    return new PrivateTxConstantData(BlockHeader.empty(), TxContext.empty(), Fr.ZERO, ProtocolContracts.empty());
+  }
+
+  getSize() {
+    return (
+      this.anchorBlockHeader.getSize() +
+      this.txContext.getSize() +
+      this.vkTreeRoot.size +
+      this.protocolContracts.getSize()
+    );
+  }
+
+  clone(): PrivateTxConstantData {
+    return PrivateTxConstantData.fromBuffer(this.toBuffer());
+  }
+}

package/src/tx/processed_tx.ts

@@ -1,14 +1,15 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 
+import type { PublicTxEffect } from '../avm/avm.js';
 import type { AvmProvingRequest } from '../avm/avm_proving_request.js';
 import type { PublicDataWrite } from '../avm/public_data_write.js';
 import { RevertCode } from '../avm/revert_code.js';
-import type { SimulationError } from '../errors/simulation_error.js';
+import { SimulationError } from '../errors/simulation_error.js';
 import { Gas } from '../gas/gas.js';
 import type { GasUsed } from '../gas/gas_used.js';
 import { computeL2ToL1MessageHash } from '../hash/hash.js';
 import type { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
-import type { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+import type { ChonkProof } from '../proofs/chonk_proof.js';
 import type { GlobalVariables } from './global_variables.js';
 import type { Tx } from './tx.js';
 import { TxEffect } from './tx_effect.js';
@@ -36,7 +37,7 @@ export type ProcessedTx = {
   /**
    * Proof for the private execution.
    */
-  clientIvcProof: ClientIvcProof;
+  chonkProof: ChonkProof;
   /**
    * The request for AVM proving.
    */
@@ -118,7 +119,7 @@ export function makeProcessedTxFromPrivateOnlyTx(
   return {
     hash: txEffect.txHash,
     data: tx.data,
-    clientIvcProof: tx.clientIvcProof,
+    chonkProof: tx.chonkProof,
     avmProvingRequest: undefined,
     globalVariables,
     txEffect,
@@ -128,25 +129,15 @@ export function makeProcessedTxFromPrivateOnlyTx(
   };
 }
 
-export function toNumBlobFields(txs: ProcessedTx[]): number {
-  return txs.reduce((acc, tx) => {
-    return acc + tx.txEffect.toBlobFields().length;
-  }, 0);
-}
-
 export function makeProcessedTxFromTxWithPublicCalls(
   tx: Tx,
-  avmProvingRequest: AvmProvingRequest,
+  globalVariables: GlobalVariables,
+  avmProvingRequest: AvmProvingRequest | undefined,
+  publicTxEffect: PublicTxEffect,
   gasUsed: GasUsed,
   revertCode: RevertCode,
   revertReason: SimulationError | undefined,
 ): ProcessedTx {
-  const avmPublicInputs = avmProvingRequest.inputs.publicInputs;
-
-  const globalVariables = avmPublicInputs.globalVariables;
-
-  const publicDataWrites = avmPublicInputs.accumulatedData.publicDataWrites.filter(w => !w.isEmpty());
-
   const privateLogs = [
     ...tx.data.forPublic!.nonRevertibleAccumulatedData.privateLogs,
     ...(revertCode.isOK() ? tx.data.forPublic!.revertibleAccumulatedData.privateLogs : []),
@@ -159,10 +150,10 @@ export function makeProcessedTxFromTxWithPublicCalls(
   const txEffect = new TxEffect(
     revertCode,
     tx.getTxHash(),
-    avmPublicInputs.transactionFee,
-    avmPublicInputs.accumulatedData.noteHashes.filter(h => !h.isZero()),
-    avmPublicInputs.accumulatedData.nullifiers.filter(h => !h.isZero()),
-    avmPublicInputs.accumulatedData.l2ToL1Msgs
+    publicTxEffect.transactionFee,
+    publicTxEffect.noteHashes,
+    publicTxEffect.nullifiers,
+    publicTxEffect.l2ToL1Msgs // convert messages to hashes.
       .filter(msg => !msg.contractAddress.isZero())
       .map(msg =>
         computeL2ToL1MessageHash({
@@ -173,21 +164,27 @@ export function makeProcessedTxFromTxWithPublicCalls(
           chainId: globalVariables.chainId,
         }),
       ),
-    publicDataWrites,
+    publicTxEffect.publicDataWrites,
     privateLogs,
-    avmPublicInputs.accumulatedData.publicLogs.filter(l => !l.isEmpty()),
+    publicTxEffect.publicLogs,
     contractClassLogs,
   );
 
+  // Some callers expect a revert reason if the tx reverted.
+  const finalRevertReason =
+    revertReason === undefined && !revertCode.isOK()
+      ? new SimulationError('TX reverted', /*functionErrorStack=*/ [], /*revertData=*/ [])
+      : revertReason;
+
   return {
     hash: txEffect.txHash,
     data: tx.data,
-    clientIvcProof: tx.clientIvcProof,
+    chonkProof: tx.chonkProof,
     avmProvingRequest,
     globalVariables,
     txEffect,
     gasUsed,
     revertCode,
-    revertReason,
+    revertReason: finalRevertReason,
   };
 }

package/src/tx/profiling.ts

@@ -1,12 +1,10 @@
-import { Fr } from '@aztec/foundation/fields';
-import { type ZodFor, optional } from '@aztec/foundation/schemas';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type ZodFor, optional, schemas } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
-import type { AbiDecoded } from '../abi/decoder.js';
 import type { AztecNode } from '../interfaces/aztec-node.js';
 import { type PrivateExecutionStep, PrivateExecutionStepSchema } from '../kernel/private_kernel_prover_output.js';
-import { AbiDecodedSchema } from '../schemas/schemas.js';
 
 export type NodeStats = Partial<Record<keyof AztecNode, { times: number[] }>>;
 
@@ -78,13 +76,11 @@ export const SimulationStatsSchema = z.object({
   nodeRPCCalls: NodeStatsSchema,
 });
 
-// docs:start:tx-profile-result
 export class TxProfileResult {
   constructor(
     public executionSteps: PrivateExecutionStep[],
     public stats: ProvingStats,
   ) {}
-  // docs:end:tx-profile-result
   static get schema(): ZodFor<TxProfileResult> {
     return z
       .object({
@@ -129,21 +125,21 @@ export class TxProfileResult {
 
 export class UtilitySimulationResult {
   constructor(
-    public result: AbiDecoded,
+    public result: Fr[],
     public stats?: SimulationStats,
   ) {}
 
   static get schema(): ZodFor<UtilitySimulationResult> {
     return z
       .object({
-        result: AbiDecodedSchema,
+        result: z.array(schemas.Fr),
         stats: optional(SimulationStatsSchema),
       })
       .transform(({ result, stats }) => new UtilitySimulationResult(result, stats));
   }
 
   static random(): UtilitySimulationResult {
-    return new UtilitySimulationResult(Fr.random().toBigInt(), {
+    return new UtilitySimulationResult([Fr.random()], {
       nodeRPCCalls: { getBlockHeader: { times: [1] } },
       timings: {
         sync: 1,

package/src/tx/protocol_contracts.ts

@@ -0,0 +1,86 @@
+import { GeneratorIndex, MAX_PROTOCOL_CONTRACTS } from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { arraySerializedSizeOfNonEmpty } from '@aztec/foundation/collection';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import {
+  BufferReader,
+  FieldReader,
+  type Tuple,
+  assertLength,
+  serializeToBuffer,
+  serializeToFields,
+} from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { z } from 'zod';
+
+import { AztecAddress } from '../aztec-address/index.js';
+
+export class ProtocolContracts {
+  constructor(public derivedAddresses: Tuple<AztecAddress, typeof MAX_PROTOCOL_CONTRACTS>) {}
+
+  static from(fields: FieldsOf<ProtocolContracts>) {
+    return new ProtocolContracts(...ProtocolContracts.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<ProtocolContracts>) {
+    return [fields.derivedAddresses] as const;
+  }
+
+  static fromFields(fields: Fr[] | FieldReader): ProtocolContracts {
+    const reader = FieldReader.asReader(fields);
+    return new ProtocolContracts(reader.readArray(MAX_PROTOCOL_CONTRACTS, AztecAddress));
+  }
+
+  toFields(): Fr[] {
+    return serializeToFields(...ProtocolContracts.getFields(this));
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): ProtocolContracts {
+    const reader = BufferReader.asReader(buffer);
+    return new ProtocolContracts(reader.readArray(MAX_PROTOCOL_CONTRACTS, AztecAddress));
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...ProtocolContracts.getFields(this));
+  }
+
+  static empty() {
+    return new ProtocolContracts(makeTuple(MAX_PROTOCOL_CONTRACTS, () => AztecAddress.zero()));
+  }
+
+  /**
+   * Creates a ProtocolContracts instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing ProtocolContracts fields
+   * @returns A ProtocolContracts instance
+   */
+  static fromPlainObject(obj: any): ProtocolContracts {
+    return new ProtocolContracts(
+      assertLength(
+        obj.derivedAddresses.map((addr: any) => AztecAddress.fromPlainObject(addr)),
+        MAX_PROTOCOL_CONTRACTS,
+      ),
+    );
+  }
+
+  getSize() {
+    return arraySerializedSizeOfNonEmpty(this.derivedAddresses);
+  }
+
+  hash() {
+    return poseidon2HashWithSeparator(this.derivedAddresses, GeneratorIndex.PROTOCOL_CONTRACTS);
+  }
+
+  static get schema() {
+    return z
+      .object({
+        derivedAddresses: AztecAddress.schema.array().min(MAX_PROTOCOL_CONTRACTS).max(MAX_PROTOCOL_CONTRACTS),
+      })
+      .transform(
+        ({ derivedAddresses }) => new ProtocolContracts(assertLength(derivedAddresses, MAX_PROTOCOL_CONTRACTS)),
+      );
+  }
+}

package/src/tx/proven_tx.ts

@@ -4,7 +4,7 @@ import type { FieldsOf } from '@aztec/foundation/types';
 import { z } from 'zod';
 
 import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
-import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+import { ChonkProof } from '../proofs/chonk_proof.js';
 import type { OffchainEffect } from './offchain_effect.js';
 import {
   PrivateExecutionResult,
@@ -18,7 +18,7 @@ export class TxProvingResult {
   constructor(
     public privateExecutionResult: PrivateExecutionResult,
     public publicInputs: PrivateKernelTailCircuitPublicInputs,
-    public clientIvcProof: ClientIvcProof,
+    public chonkProof: ChonkProof,
     public stats?: ProvingStats,
   ) {}
 
@@ -27,7 +27,7 @@ export class TxProvingResult {
 
     return await Tx.create({
       data: this.publicInputs,
-      clientIvcProof: this.clientIvcProof,
+      chonkProof: this.chonkProof,
       contractClassLogFields: contractClassLogs,
       publicFunctionCalldata: this.privateExecutionResult.publicFunctionCalldata,
     });
@@ -42,21 +42,21 @@ export class TxProvingResult {
       .object({
         privateExecutionResult: PrivateExecutionResult.schema,
         publicInputs: PrivateKernelTailCircuitPublicInputs.schema,
-        clientIvcProof: ClientIvcProof.schema,
+        chonkProof: ChonkProof.schema,
         timings: optional(ProvingTimingsSchema),
       })
       .transform(TxProvingResult.from);
   }
 
   static from(fields: FieldsOf<TxProvingResult>) {
-    return new TxProvingResult(fields.privateExecutionResult, fields.publicInputs, fields.clientIvcProof);
+    return new TxProvingResult(fields.privateExecutionResult, fields.publicInputs, fields.chonkProof);
   }
 
   static async random() {
     return new TxProvingResult(
       await PrivateExecutionResult.random(),
       PrivateKernelTailCircuitPublicInputs.empty(),
-      ClientIvcProof.empty(),
+      ChonkProof.empty(),
     );
   }
 }

package/src/tx/public_call_request_with_calldata.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { inspect } from 'util';
@@ -46,6 +46,23 @@ export class PublicCallRequestWithCalldata {
     return new PublicCallRequestWithCalldata(fields.request, fields.calldata);
   }
 
+  /**
+   * Creates a PublicCallRequestWithCalldata from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing PublicCallRequestWithCalldata fields
+   * @returns A PublicCallRequestWithCalldata instance
+   */
+  static fromPlainObject(obj: any): PublicCallRequestWithCalldata {
+    if (obj instanceof PublicCallRequestWithCalldata) {
+      return obj;
+    }
+    return new PublicCallRequestWithCalldata(
+      PublicCallRequest.fromPlainObject(obj.request),
+      obj.calldata.map((f: any) => Fr.fromPlainObject(f)),
+    );
+  }
+
   toBuffer() {
     return serializeToBuffer(this.request, new Vector(this.calldata));
   }