@aztec/stdlib 3.0.0-canary.a9708bd → 3.0.0-manual.20251030

package/src/tx/processed_tx.ts

@@ -8,7 +8,7 @@ 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 +36,7 @@ export type ProcessedTx = {
   /**
    * Proof for the private execution.
    */
-  clientIvcProof: ClientIvcProof;
+  chonkProof: ChonkProof;
   /**
    * The request for AVM proving.
    */
@@ -118,7 +118,7 @@ export function makeProcessedTxFromPrivateOnlyTx(
   return {
     hash: txEffect.txHash,
     data: tx.data,
-    clientIvcProof: tx.clientIvcProof,
+    chonkProof: tx.chonkProof,
     avmProvingRequest: undefined,
     globalVariables,
     txEffect,
@@ -128,12 +128,6 @@ 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,
@@ -175,14 +169,14 @@ export function makeProcessedTxFromTxWithPublicCalls(
       ),
     publicDataWrites,
     privateLogs,
-    avmPublicInputs.accumulatedData.publicLogs.filter(l => !l.isEmpty()),
+    avmPublicInputs.accumulatedData.publicLogs.toLogs(),
     contractClassLogs,
   );
 
   return {
     hash: txEffect.txHash,
     data: tx.data,
-    clientIvcProof: tx.clientIvcProof,
+    chonkProof: tx.chonkProof,
     avmProvingRequest,
     globalVariables,
     txEffect,

package/src/tx/profiling.ts

@@ -78,13 +78,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({

package/src/tx/protocol_contracts.ts

@@ -0,0 +1,70 @@
+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';
+import { Fr } from '@aztec/foundation/fields';
+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()));
+  }
+
+  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/simulated_tx.ts

@@ -11,7 +11,7 @@ import {
 import { Gas } from '../gas/gas.js';
 import type { GasUsed } from '../gas/gas_used.js';
 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 {
   PrivateCallExecutionResult,
   PrivateExecutionResult,
@@ -69,7 +69,7 @@ export class PrivateSimulationResult {
 
     return await Tx.create({
       data: this.publicInputs,
-      clientIvcProof: ClientIvcProof.empty(),
+      chonkProof: ChonkProof.empty(),
       contractClassLogFields: contractClassLogs,
       publicFunctionCalldata: this.privateExecutionResult.publicFunctionCalldata,
     });

package/src/tx/state_reference.ts

@@ -78,6 +78,10 @@ export class StateReference {
     return new StateReference(AppendOnlyTreeSnapshot.empty(), PartialStateReference.empty());
   }
 
+  static random(): StateReference {
+    return new StateReference(AppendOnlyTreeSnapshot.random(), PartialStateReference.random());
+  }
+
   toViem(): ViemStateReference {
     return {
       l1ToL2MessageTree: this.l1ToL2MessageTree.toViem(),
@@ -133,6 +137,6 @@ export class StateReference {
   }
 
   public equals(other: this): boolean {
-    return this.l1ToL2MessageTree.root.equals(other.l1ToL2MessageTree.root) && this.partial.equals(other.partial);
+    return this.l1ToL2MessageTree.equals(other.l1ToL2MessageTree) && this.partial.equals(other.partial);
   }
 }

package/src/tx/tx.ts

@@ -15,7 +15,7 @@ import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_t
 import { ContractClassLog, ContractClassLogFields } from '../logs/contract_class_log.js';
 import { Gossipable } from '../p2p/gossipable.js';
 import { TopicType } from '../p2p/topic_type.js';
-import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+import { ChonkProof } from '../proofs/chonk_proof.js';
 import type { TxStats } from '../stats/stats.js';
 import { HashedValues } from './hashed_values.js';
 import { PublicCallRequestWithCalldata } from './public_call_request_with_calldata.js';
@@ -38,9 +38,8 @@ export class Tx extends Gossipable {
     public readonly data: PrivateKernelTailCircuitPublicInputs,
     /**
      * Proof from the private kernel circuit.
-     * TODO(#7368): This client IVC object currently contains various VKs that will eventually be more like static data.
      */
-    public readonly clientIvcProof: ClientIvcProof,
+    public readonly chonkProof: ChonkProof,
     /**
      * Contract class log fields emitted from the tx.
      * Their order should match the order of the log hashes returned from `this.data.getNonEmptyContractClassLogsHashes`.
@@ -109,7 +108,7 @@ export class Tx extends Gossipable {
     return new Tx(
       reader.readObject(TxHash),
       reader.readObject(PrivateKernelTailCircuitPublicInputs),
-      reader.readObject(ClientIvcProof),
+      reader.readObject(ChonkProof),
       reader.readVectorUint8Prefix(ContractClassLogFields),
       reader.readVectorUint8Prefix(HashedValues),
     );
@@ -123,7 +122,7 @@ export class Tx extends Gossipable {
     return serializeToBuffer([
       this.txHash,
       this.data,
-      this.clientIvcProof,
+      this.chonkProof,
       serializeArrayOfBufferableToVector(this.contractClassLogFields, 1),
       serializeArrayOfBufferableToVector(this.publicFunctionCalldata, 1),
     ]);
@@ -133,7 +132,7 @@ export class Tx extends Gossipable {
     return z
       .object({
         data: PrivateKernelTailCircuitPublicInputs.schema,
-        clientIvcProof: ClientIvcProof.schema,
+        chonkProof: ChonkProof.schema,
         contractClassLogFields: z.array(ContractClassLogFields.schema),
         publicFunctionCalldata: z.array(HashedValues.schema),
       })
@@ -156,12 +155,22 @@ export class Tx extends Gossipable {
     return new Tx(
       fields.txHash,
       fields.data,
-      fields.clientIvcProof,
+      fields.chonkProof,
       fields.contractClassLogFields,
       fields.publicFunctionCalldata,
     );
   }
 
+  /**
+   * Validates that the tx hash matches the computed hash from the tx data.
+   * This should be called when deserializing a tx from an untrusted source.
+   * @returns true if the hash is valid, false otherwise
+   */
+  async validateTxHash(): Promise<boolean> {
+    const expectedHash = await Tx.computeTxHash(this);
+    return this.txHash.equals(expectedHash);
+  }
+
   /**
    * Gets public logs emitted by this tx.
    * @param logsSource - An instance of `L2LogsSource` which can be used to obtain the logs.
@@ -207,16 +216,6 @@ export class Tx extends Gossipable {
     return this.txHash;
   }
 
-  /**
-   * Allows setting the hash of the Tx.
-   * Use this when you want to skip computing it from the original data.
-   * Don't set a Tx hash received from an untrusted source.
-   * @param hash - The hash to set.
-   */
-  setTxHash(_hash: TxHash) {
-    return this;
-  }
-
   getCalldataMap(): Map<string, Fr[]> {
     if (!this.calldataMap) {
       const calldataMap = new Map();
@@ -238,7 +237,7 @@ export class Tx extends Gossipable {
       classPublishedCount: this.data.getNonEmptyContractClassLogsHashes().length,
       contractClassLogSize: this.data.getEmittedContractClassLogsLength(),
 
-      proofSize: this.clientIvcProof.clientIvcProofBuffer.length,
+      proofSize: this.chonkProof.fields.length,
       size: this.toBuffer().length,
 
       feePaymentMethod:
@@ -250,7 +249,7 @@ export class Tx extends Gossipable {
   getSize() {
     return (
       this.data.getSize() +
-      this.clientIvcProof.clientIvcProofBuffer.length +
+      this.chonkProof.fields.length * Fr.SIZE_IN_BYTES +
       arraySerializedSizeOfNonEmpty(this.contractClassLogFields) +
       this.publicFunctionCalldata.reduce((accum, cd) => accum + cd.getSize(), 0)
     );
@@ -276,10 +275,10 @@ export class Tx extends Gossipable {
    */
   static clone(tx: Tx): Tx {
     const publicInputs = PrivateKernelTailCircuitPublicInputs.fromBuffer(tx.data.toBuffer());
-    const clientIvcProof = ClientIvcProof.fromBuffer(tx.clientIvcProof.toBuffer());
+    const chonkProof = ChonkProof.fromBuffer(tx.chonkProof.toBuffer());
     const contractClassLogFields = tx.contractClassLogFields.map(p => p.clone());
     const publicFunctionCalldata = tx.publicFunctionCalldata.map(cd => HashedValues.fromBuffer(cd.toBuffer()));
-    const clonedTx = new Tx(tx.txHash, publicInputs, clientIvcProof, contractClassLogFields, publicFunctionCalldata);
+    const clonedTx = new Tx(tx.txHash, publicInputs, chonkProof, contractClassLogFields, publicFunctionCalldata);
 
     return clonedTx;
   }
@@ -293,7 +292,7 @@ export class Tx extends Gossipable {
     return Tx.from({
       txHash: (typeof args.txHash === 'string' ? TxHash.fromString(args.txHash) : args.txHash) ?? TxHash.random(),
       data: PrivateKernelTailCircuitPublicInputs.emptyWithNullifier(),
-      clientIvcProof: args.randomProof ? ClientIvcProof.random() : ClientIvcProof.empty(),
+      chonkProof: args.randomProof ? ChonkProof.random() : ChonkProof.empty(),
       contractClassLogFields: [ContractClassLogFields.random()],
       publicFunctionCalldata: [HashedValues.random()],
     });

package/src/tx/tx_constant_data.ts

@@ -7,29 +7,16 @@ import { BlockHeader } from './block_header.js';
 import { TxContext } from './tx_context.js';
 
 /**
- * Data that is constant/not modified by neither of the kernels.
+ * Version of `PrivateTxConstantData` exposed by the tail circuits
+ * It compresses the protocol contracts list to a hash to minimize the number of public inputs.
+ * Refer to `PrivateTxConstantData` for more details.
  */
 export class TxConstantData {
   constructor(
-    /** Header of a block whose state is used during execution (not the block the transaction is included in). */
-    public historicalHeader: BlockHeader,
-    /**
-     * Context of the transaction.
-     *
-     * Note: `chainId` and `version` in txContext are not redundant to the values in
-     * self.historical_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 anchorBlockHeader: BlockHeader,
     public txContext: TxContext,
-    /**
-     * Root of the vk tree for the protocol circuits.
-     */
     public vkTreeRoot: Fr,
-    /**
-     * Root of the tree for the protocol contracts.
-     */
-    public protocolContractTreeRoot: Fr,
+    public protocolContractsHash: Fr,
   ) {}
 
   static from(fields: FieldsOf<TxConstantData>) {
@@ -37,7 +24,7 @@ export class TxConstantData {
   }
 
   static getFields(fields: FieldsOf<TxConstantData>) {
-    return [fields.historicalHeader, fields.txContext, fields.vkTreeRoot, fields.protocolContractTreeRoot] as const;
+    return [fields.anchorBlockHeader, fields.txContext, fields.vkTreeRoot, fields.protocolContractsHash] as const;
   }
 
   static fromFields(fields: Fr[] | FieldReader): TxConstantData {
@@ -80,10 +67,10 @@ export class TxConstantData {
 
   getSize() {
     return (
-      this.historicalHeader.getSize() +
+      this.anchorBlockHeader.getSize() +
       this.txContext.getSize() +
       this.vkTreeRoot.size +
-      this.protocolContractTreeRoot.size
+      this.protocolContractsHash.size
     );
   }