@aztec/stdlib 0.86.0 → 0.87.0

package/src/tx/content_commitment.ts

@@ -9,7 +9,12 @@ import { z } from 'zod';
 export const NUM_BYTES_PER_SHA256 = 32;
 
 export class ContentCommitment {
-  constructor(public numTxs: Fr, public blobsHash: Buffer, public inHash: Buffer, public outHash: Buffer) {
+  constructor(
+    public numTxs: Fr,
+    public blobsHash: Buffer,
+    public inHash: Buffer,
+    public outHash: Buffer,
+  ) {
     // NB: we do not calculate blobHash in the circuit, but we still truncate it so it fits in a field
     if (blobsHash.length !== NUM_BYTES_PER_SHA256) {
       throw new Error(`blobsHash buffer must be ${NUM_BYTES_PER_SHA256} bytes`);

package/src/tx/index.ts

@@ -11,13 +11,13 @@ 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';
 export * from './tx.js';
 export * from './processed_tx.js';
 export * from './proven_tx.js';
-export * from './profiled_tx.js';
 export * from './simulated_tx.js';
 export * from './tx_effect.js';
 export * from './public_simulation_output.js';
@@ -29,3 +29,4 @@ export * from './capsule.js';
 export * from './global_variable_builder.js';
 export * from './hashed_values.js';
 export * from './indexed_tx_effect.js';
+export * from './profiling.js';

package/src/tx/private_execution_result.ts

@@ -9,7 +9,7 @@ import { NoteSelector } from '../abi/note_selector.js';
 import { PrivateCircuitPublicInputs } from '../kernel/private_circuit_public_inputs.js';
 import type { IsEmpty } from '../kernel/utils/interfaces.js';
 import { sortByCounter } from '../kernel/utils/order_and_comparison.js';
-import { ContractClassLog } from '../logs/contract_class_log.js';
+import { ContractClassLog, ContractClassLogFields } from '../logs/contract_class_log.js';
 import { Note } from '../note/note.js';
 import { type ZodFor, mapSchema, schemas } from '../schemas/index.js';
 import { HashedValues } from './hashed_values.js';
@@ -47,7 +47,10 @@ export class NoteAndSlot {
 }
 
 export class CountedContractClassLog implements IsEmpty {
-  constructor(public log: ContractClassLog, public counter: number) {}
+  constructor(
+    public log: ContractClassLog,
+    public counter: number,
+  ) {}
 
   static get schema(): ZodFor<CountedContractClassLog> {
     return z
@@ -132,9 +135,11 @@ export class PrivateCallExecutionResult {
     public nestedExecutions: PrivateCallExecutionResult[],
     /**
      * Contract class logs emitted during execution of this function call.
-     * Note: These are preimages to `contractClassLogsHashes`.
+     * Note: We only need to collect the ContractClassLogFields as preimages for the tx.
+     * But keep them as ContractClassLog so that we can verify the log hashes before submitting the tx (TODO).
      */
     public contractClassLogs: CountedContractClassLog[],
+    public profileResult?: PrivateExecutionProfileResult,
   ) {}
 
   static get schema(): ZodFor<PrivateCallExecutionResult> {
@@ -222,10 +227,10 @@ function collectContractClassLogs(execResult: PrivateCallExecutionResult): Count
  * @param execResult - The topmost execution result.
  * @returns All contract class logs.
  */
-export function collectSortedContractClassLogs(execResult: PrivateExecutionResult): ContractClassLog[] {
+export function collectSortedContractClassLogs(execResult: PrivateExecutionResult): ContractClassLogFields[] {
   const allLogs = collectContractClassLogs(execResult.entrypoint);
   const sortedLogs = sortByCounter(allLogs);
-  return sortedLogs.map(l => l.log);
+  return sortedLogs.map(l => l.log.fields);
 }
 
 export function getFinalMinRevertibleSideEffectCounter(execResult: PrivateExecutionResult): number {
@@ -248,3 +253,7 @@ export function collectNested<T>(
     executionStack.flatMap(({ nestedExecutions }) => collectNested(nestedExecutions, extractExecutionItems)),
   );
 }
+
+export class PrivateExecutionProfileResult {
+  constructor(public timings: { witgen: number }) {}
+}

package/src/tx/profiling.ts

@@ -0,0 +1,126 @@
+import { Fr } from '@aztec/foundation/fields';
+import { type ZodFor, optional } from '@aztec/foundation/schemas';
+
+import { z } from 'zod';
+
+import type { AbiDecoded } from '../abi/decoder.js';
+import { type PrivateExecutionStep, PrivateExecutionStepSchema } from '../kernel/private_kernel_prover_output.js';
+import { AbiDecodedSchema } from '../schemas/schemas.js';
+
+type FunctionTiming = {
+  functionName: string;
+  time: number;
+};
+
+const FunctionTimingSchema = z.object({ functionName: z.string(), time: z.number() });
+
+export type ProvingTimings = {
+  sync?: number;
+  proving?: number;
+  perFunction: FunctionTiming[];
+  unaccounted: number;
+  total: number;
+};
+
+export const ProvingTimingsSchema = z.object({
+  sync: optional(z.number()),
+  proving: optional(z.number()),
+  perFunction: z.array(FunctionTimingSchema),
+  unaccounted: z.number(),
+  total: z.number(),
+});
+
+export interface SimulationTimings {
+  sync: number;
+  publicSimulation?: number;
+  validation?: number;
+  perFunction: FunctionTiming[];
+  unaccounted: number;
+  total: number;
+}
+
+export const SimulationTimingsSchema = z.object({
+  sync: z.number(),
+  publicSimulation: optional(z.number()),
+  validation: optional(z.number()),
+  perFunction: z.array(FunctionTimingSchema),
+  unaccounted: z.number(),
+  total: z.number(),
+});
+
+export class TxProfileResult {
+  constructor(
+    public executionSteps: PrivateExecutionStep[],
+    public timings: ProvingTimings,
+  ) {}
+
+  static get schema(): ZodFor<TxProfileResult> {
+    return z
+      .object({
+        executionSteps: z.array(PrivateExecutionStepSchema),
+        timings: ProvingTimingsSchema,
+      })
+      .transform(({ executionSteps, timings }) => new TxProfileResult(executionSteps, timings));
+  }
+
+  static random(): TxProfileResult {
+    return new TxProfileResult(
+      [
+        {
+          functionName: 'random',
+          bytecode: Buffer.from('random'),
+          witness: new Map([[1, 'random']]),
+          vk: Buffer.from('random'),
+          timings: {
+            witgen: 1,
+            gateCount: 1,
+          },
+        },
+      ],
+      {
+        sync: 1,
+        proving: 1,
+        perFunction: [
+          {
+            functionName: 'random',
+            time: 1,
+          },
+        ],
+        unaccounted: 1,
+        total: 4,
+      },
+    );
+  }
+}
+
+export class UtilitySimulationResult {
+  constructor(
+    public result: AbiDecoded,
+    public timings?: SimulationTimings,
+  ) {}
+
+  static get schema(): ZodFor<UtilitySimulationResult> {
+    return z
+      .object({
+        result: AbiDecodedSchema,
+        timings: optional(SimulationTimingsSchema),
+      })
+      .transform(({ result, timings }) => new UtilitySimulationResult(result, timings));
+  }
+
+  static random(): UtilitySimulationResult {
+    return new UtilitySimulationResult(Fr.random().toBigInt(), {
+      sync: 1,
+      publicSimulation: 1,
+      validation: 1,
+      perFunction: [
+        {
+          functionName: 'random',
+          time: 1,
+        },
+      ],
+      unaccounted: 1,
+      total: 5,
+    });
+  }
+}

package/src/tx/proposed_block_header.ts

@@ -0,0 +1,169 @@
+import { sha256ToField } from '@aztec/foundation/crypto';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import type { ZodFor } from '@aztec/foundation/schemas';
+import { BufferReader, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { inspect } from 'util';
+import { z } from 'zod';
+
+import { AztecAddress } from '../aztec-address/index.js';
+import { GasFees } from '../gas/index.js';
+import { schemas } from '../schemas/index.js';
+import type { UInt64 } from '../types/shared.js';
+import { ContentCommitment } from './content_commitment.js';
+
+/** The proposed values of an L2 block. */
+export class ProposedBlockHeader {
+  constructor(
+    /** Root of the archive tree before this block is added. */
+    public lastArchiveRoot: Fr,
+    /** Content commitment of the L2 block. */
+    public contentCommitment: ContentCommitment,
+    /** Slot number of the L2 block */
+    public slotNumber: Fr,
+    /** Timestamp of the L2 block. */
+    public timestamp: UInt64,
+    /** Recipient of block reward. */
+    public coinbase: EthAddress,
+    /** Address to receive fees. */
+    public feeRecipient: AztecAddress,
+    /** Global gas prices for this block. */
+    public gasFees: GasFees,
+    /** Total mana used in the block, computed by the root rollup circuit */
+    public totalManaUsed: Fr,
+  ) {}
+
+  static get schema(): ZodFor<ProposedBlockHeader> {
+    return z
+      .object({
+        lastArchiveRoot: schemas.Fr,
+        contentCommitment: ContentCommitment.schema,
+        slotNumber: schemas.Fr,
+        timestamp: schemas.BigInt,
+        coinbase: schemas.EthAddress,
+        feeRecipient: schemas.AztecAddress,
+        gasFees: GasFees.schema,
+        totalManaUsed: schemas.Fr,
+      })
+      .transform(ProposedBlockHeader.from);
+  }
+
+  static getFields(fields: FieldsOf<ProposedBlockHeader>) {
+    return [
+      fields.lastArchiveRoot,
+      fields.contentCommitment,
+      fields.slotNumber,
+      fields.timestamp,
+      fields.coinbase,
+      fields.feeRecipient,
+      fields.gasFees,
+      fields.totalManaUsed,
+    ] as const;
+  }
+
+  static from(fields: FieldsOf<ProposedBlockHeader>) {
+    return new ProposedBlockHeader(...ProposedBlockHeader.getFields(fields));
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): ProposedBlockHeader {
+    const reader = BufferReader.asReader(buffer);
+
+    return new ProposedBlockHeader(
+      reader.readObject(Fr),
+      reader.readObject(ContentCommitment),
+      Fr.fromBuffer(reader),
+      reader.readUInt64(),
+      reader.readObject(EthAddress),
+      reader.readObject(AztecAddress),
+      reader.readObject(GasFees),
+      reader.readObject(Fr),
+    );
+  }
+
+  toBuffer() {
+    // Note: The order here must match the order in the HeaderLib solidity library.
+    return serializeToBuffer([
+      this.lastArchiveRoot,
+      this.contentCommitment,
+      this.slotNumber,
+      bigintToUInt64BE(this.timestamp),
+      this.coinbase,
+      this.feeRecipient,
+      this.gasFees,
+      this.totalManaUsed,
+    ]);
+  }
+
+  hash(): Fr {
+    return sha256ToField([this.toBuffer()]);
+  }
+
+  static empty(fields: Partial<FieldsOf<ProposedBlockHeader>> = {}): ProposedBlockHeader {
+    return ProposedBlockHeader.from({
+      lastArchiveRoot: Fr.ZERO,
+      contentCommitment: ContentCommitment.empty(),
+      slotNumber: Fr.ZERO,
+      timestamp: 0n,
+      coinbase: EthAddress.ZERO,
+      feeRecipient: AztecAddress.ZERO,
+      gasFees: GasFees.empty(),
+      totalManaUsed: Fr.ZERO,
+      ...fields,
+    });
+  }
+
+  isEmpty(): boolean {
+    return (
+      this.lastArchiveRoot.isZero() &&
+      this.contentCommitment.isEmpty() &&
+      this.slotNumber.isZero() &&
+      this.timestamp === 0n &&
+      this.coinbase.isZero() &&
+      this.feeRecipient.isZero() &&
+      this.gasFees.isEmpty() &&
+      this.totalManaUsed.isZero()
+    );
+  }
+
+  /**
+   * Serializes this instance into a string.
+   * @returns Encoded string.
+   */
+  public toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static fromString(str: string): ProposedBlockHeader {
+    return ProposedBlockHeader.fromBuffer(hexToBuffer(str));
+  }
+
+  toInspect() {
+    return {
+      lastArchive: this.lastArchiveRoot.toString(),
+      contentCommitment: this.contentCommitment.toInspect(),
+      slotNumber: this.slotNumber.toBigInt(),
+      timestamp: this.timestamp,
+      coinbase: this.coinbase.toString(),
+      feeRecipient: this.feeRecipient.toString(),
+      gasFees: this.gasFees.toInspect(),
+      totalManaUsed: this.totalManaUsed.toBigInt(),
+    };
+  }
+
+  [inspect.custom]() {
+    const gasfees = `da:${this.gasFees.feePerDaGas.toBigInt()}, l2:${this.gasFees.feePerL2Gas.toBigInt()}`;
+    return `Header {
+  lastArchiveRoot: ${this.lastArchiveRoot.toString()},
+  contentCommitment: ${inspect(this.contentCommitment)},
+  slotNumber: ${this.slotNumber.toBigInt()},
+  timestamp: ${this.timestamp},
+  coinbase: ${this.coinbase.toString()},
+  feeRecipient: ${this.feeRecipient.toString()},
+  gasFees: ${gasfees},
+  totalManaUsed: ${this.totalManaUsed.toBigInt()},
+}`;
+  }
+}

package/src/tx/proven_tx.ts

@@ -1,3 +1,4 @@
+import { optional } from '@aztec/foundation/schemas';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
@@ -5,6 +6,7 @@ import { z } from 'zod';
 import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
 import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
 import { PrivateExecutionResult, collectSortedContractClassLogs } from './private_execution_result.js';
+import { type ProvingTimings, SimulationTimingsSchema } from './profiling.js';
 import { Tx } from './tx.js';
 
 export class TxProvingResult {
@@ -12,6 +14,7 @@ export class TxProvingResult {
     public privateExecutionResult: PrivateExecutionResult,
     public publicInputs: PrivateKernelTailCircuitPublicInputs,
     public clientIvcProof: ClientIvcProof,
+    public timings?: ProvingTimings,
   ) {}
 
   toTx(): Tx {
@@ -32,6 +35,7 @@ export class TxProvingResult {
         privateExecutionResult: PrivateExecutionResult.schema,
         publicInputs: PrivateKernelTailCircuitPublicInputs.schema,
         clientIvcProof: ClientIvcProof.schema,
+        timings: optional(SimulationTimingsSchema),
       })
       .transform(TxProvingResult.from);
   }

package/src/tx/simulated_tx.ts

@@ -1,4 +1,4 @@
-import type { ZodFor } from '@aztec/foundation/schemas';
+import { type ZodFor, optional } from '@aztec/foundation/schemas';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
@@ -12,6 +12,7 @@ import {
   PrivateExecutionResult,
   collectSortedContractClassLogs,
 } from './private_execution_result.js';
+import { type SimulationTimings, SimulationTimingsSchema } from './profiling.js';
 import { NestedProcessReturnValues, PublicSimulationOutput } from './public_simulation_output.js';
 import { Tx } from './tx.js';
 
@@ -43,6 +44,7 @@ export class TxSimulationResult {
     public privateExecutionResult: PrivateExecutionResult,
     public publicInputs: PrivateKernelTailCircuitPublicInputs,
     public publicOutput?: PublicSimulationOutput,
+    public timings?: SimulationTimings,
   ) {}
 
   get gasUsed(): GasUsed {
@@ -62,22 +64,30 @@ export class TxSimulationResult {
         privateExecutionResult: PrivateExecutionResult.schema,
         publicInputs: PrivateKernelTailCircuitPublicInputs.schema,
         publicOutput: PublicSimulationOutput.schema.optional(),
+        timings: optional(SimulationTimingsSchema),
       })
       .transform(TxSimulationResult.from);
   }
 
   static from(fields: Omit<FieldsOf<TxSimulationResult>, 'gasUsed'>) {
-    return new TxSimulationResult(fields.privateExecutionResult, fields.publicInputs, fields.publicOutput);
+    return new TxSimulationResult(
+      fields.privateExecutionResult,
+      fields.publicInputs,
+      fields.publicOutput,
+      fields.timings,
+    );
   }
 
   static fromPrivateSimulationResultAndPublicOutput(
     privateSimulationResult: PrivateSimulationResult,
     publicOutput?: PublicSimulationOutput,
+    timings?: SimulationTimings,
   ) {
     return new TxSimulationResult(
       privateSimulationResult.privateExecutionResult,
       privateSimulationResult.publicInputs,
       publicOutput,
+      timings,
     );
   }
 

package/src/tx/tx.ts

@@ -13,7 +13,7 @@ import type { L2LogsSource } from '../interfaces/l2_logs_source.js';
 import type { PublicCallRequest } from '../kernel/index.js';
 import type { ScopedLogHash } from '../kernel/log_hash.js';
 import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
-import { ContractClassLog } from '../logs/contract_class_log.js';
+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';
@@ -44,7 +44,7 @@ export class Tx extends Gossipable {
     /**
      * Contract class logs generated by the tx.
      */
-    public contractClassLogs: ContractClassLog[],
+    public contractClassLogs: ContractClassLogFields[],
     /**
      * An array of calldata for the enqueued public function calls and the teardown function call.
      */
@@ -54,7 +54,7 @@ export class Tx extends Gossipable {
   }
 
   // Gossipable method
-  override async p2pMessageIdentifier(): Promise<Buffer32> {
+  override async generateP2PMessageIdentifier(): Promise<Buffer32> {
     return new Buffer32((await this.getTxHash()).toBuffer());
   }
 
@@ -107,7 +107,7 @@ export class Tx extends Gossipable {
     return new Tx(
       reader.readObject(PrivateKernelTailCircuitPublicInputs),
       reader.readObject(ClientIvcProof),
-      reader.readVectorUint8Prefix(ContractClassLog),
+      reader.readVectorUint8Prefix(ContractClassLogFields),
       reader.readVectorUint8Prefix(HashedValues),
     );
   }
@@ -130,7 +130,7 @@ export class Tx extends Gossipable {
       .object({
         data: PrivateKernelTailCircuitPublicInputs.schema,
         clientIvcProof: ClientIvcProof.schema,
-        contractClassLogs: z.array(ContractClassLog.schema),
+        contractClassLogs: z.array(ContractClassLogFields.schema),
         publicFunctionCalldata: z.array(HashedValues.schema),
       })
       .transform(Tx.from);
@@ -173,12 +173,15 @@ export class Tx extends Gossipable {
    */
   async filterContractClassLogs(logHashes: ScopedLogHash[], silo: boolean = false): Promise<ContractClassLog[]> {
     const contractClassLogs = [];
-    for (const log of this.contractClassLogs) {
-      const hashedLog = await log.hash();
-      const logHash = logHashes.find(
-        hash => hash.value.equals(hashedLog) && hash.contractAddress.equals(log.contractAddress),
-      );
+    for (const fields of this.contractClassLogs) {
+      const hashedLog = await fields.hash();
+      const logHash = logHashes.find(hash => hash.value.equals(hashedLog));
       if (logHash) {
+        const log = ContractClassLog.from({
+          contractAddress: logHash.contractAddress,
+          fields,
+          emittedLength: logHash.logHash.length,
+        });
         contractClassLogs.push(silo ? await log.silo() : log);
       }
     }
@@ -287,7 +290,7 @@ 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 contractClassLogs = tx.contractClassLogs.map(x => ContractClassLog.fromBuffer(x.toBuffer()));
+    const contractClassLogs = tx.contractClassLogs.map(p => p.clone());
     const publicFunctionCalldata = tx.publicFunctionCalldata.map(cd => HashedValues.fromBuffer(cd.toBuffer()));
     const clonedTx = new Tx(publicInputs, clientIvcProof, contractClassLogs, publicFunctionCalldata);
     if (tx.txHash) {
@@ -302,11 +305,11 @@ export class Tx extends Gossipable {
    * @param randomProof - Whether to create a random proof - this will be random bytes of the full size.
    * @returns A random tx.
    */
-  static async random(randomProof = false) {
+  static random(randomProof = false) {
     return new Tx(
       PrivateKernelTailCircuitPublicInputs.emptyWithNullifier(),
       randomProof ? ClientIvcProof.random() : ClientIvcProof.empty(),
-      [await ContractClassLog.random()],
+      [ContractClassLogFields.random()],
       [HashedValues.random()],
     );
   }
@@ -321,12 +324,10 @@ export class Tx extends Gossipable {
    * The logic therefore is to drop all FunctionLogs if any constituent hash
    * does not appear in the provided hashes: it is impossible for part of a
    * function to revert.
-   *
-   * @param logHashes the individual log hashes we want to keep
-   * @param out the output to put passing logs in, to keep this function abstract
    */
+  // TODO: don't modify the tx object directly. The preimages should match the log hashes. When did the log hashes change?
   public async filterRevertedLogs() {
-    this.contractClassLogs = await this.getSplitContractClassLogs(false);
+    this.contractClassLogs = (await this.getSplitContractClassLogs(false)).map(log => log.fields);
   }
 
   #combinePublicCallRequestWithCallData(request: PublicCallRequest) {