@aztec/stdlib 0.77.0-testnet-ignition.17

package/src/rollup/tube_inputs.ts

@@ -0,0 +1,70 @@
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+
+export class TubeInputs {
+  constructor(public clientIVCData: ClientIvcProof) {}
+
+  static from(fields: FieldsOf<TubeInputs>): TubeInputs {
+    return new TubeInputs(...TubeInputs.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<TubeInputs>) {
+    return [fields.clientIVCData] as const;
+  }
+
+  /**
+   * Serializes the inputs to a buffer.
+   * @returns The inputs serialized to a buffer.
+   */
+  toBuffer() {
+    return serializeToBuffer(...TubeInputs.getFields(this));
+  }
+
+  /**
+   * Serializes the inputs to a hex string.
+   * @returns The instance serialized to a hex string.
+   */
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  /**
+   * Deserializes the inputs from a buffer.
+   * @param buffer - The buffer to deserialize from.
+   * @returns A new TubeInputs instance.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): TubeInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new TubeInputs(reader.readObject(ClientIvcProof));
+  }
+
+  isEmpty(): boolean {
+    return this.clientIVCData.isEmpty();
+  }
+  /**
+   * Deserializes the inputs from a hex string.
+   * @param str - A hex string to deserialize from.
+   * @returns A new TubeInputs instance.
+   */
+  static fromString(str: string) {
+    return TubeInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  static empty() {
+    return new TubeInputs(ClientIvcProof.empty());
+  }
+
+  /** Returns a hex representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  /** Creates an instance from a hex string. */
+  static get schema() {
+    return bufferSchemaFor(TubeInputs);
+  }
+}

package/src/schemas/index.ts

@@ -0,0 +1 @@
+export * from './schemas.js';

package/src/schemas/schemas.ts

@@ -0,0 +1,83 @@
+import type { Buffer32 } from '@aztec/foundation/buffer';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { Fq, Fr, Point } from '@aztec/foundation/fields';
+import { type ZodFor, schemas as foundationSchemas } from '@aztec/foundation/schemas';
+
+import { z } from 'zod';
+
+import type { AbiDecoded } from '../abi/decoder.js';
+import { EventSelector } from '../abi/event_selector.js';
+import { FunctionSelector } from '../abi/function_selector.js';
+import { NoteSelector } from '../abi/note_selector.js';
+import { AztecAddress } from '../aztec-address/index.js';
+
+/**
+ * Validation schemas for common types. Every schema must match its toJSON.
+ * Foundation schemas are repeated here to aid type inference
+ * */
+export const schemas = {
+  /** Accepts a hex string. */
+  EthAddress: foundationSchemas.EthAddress as ZodFor<EthAddress>,
+
+  /** Accepts a hex string. */
+  Fr: foundationSchemas.Fr as ZodFor<Fr>,
+
+  /** Accepts a hex string. */
+  Fq: foundationSchemas.Fq as ZodFor<Fq>,
+
+  /** Point. Serialized as a hex string. */
+  Point: foundationSchemas.Point as ZodFor<Point>,
+
+  /** Coerces any input to bigint. */
+  BigInt: foundationSchemas.BigInt,
+
+  /** Coerces any input to integer number. */
+  Integer: foundationSchemas.Integer,
+
+  /** Coerces input to UInt32. */
+  UInt32: foundationSchemas.UInt32,
+
+  /** Accepts a hex string as a Buffer32 type. */
+  Buffer32: foundationSchemas.Buffer32 as ZodFor<Buffer32>,
+
+  /** Accepts a base64 string or an object `{ type: 'Buffer', data: [byte, byte...] }` as a buffer. */
+  Buffer: foundationSchemas.Buffer,
+
+  /** Accepts a hex string as a buffer. */
+  BufferHex: foundationSchemas.BufferHex,
+
+  /** Hex string with an optional 0x prefix which gets removed as part of the parsing. */
+  HexString: foundationSchemas.HexString,
+
+  /** Accepts a hex string. */
+  AztecAddress: AztecAddress.schema,
+
+  /** Accepts a hex string. */
+  NoteSelector: NoteSelector.schema,
+
+  /** Accepts a hex string. */
+  FunctionSelector: FunctionSelector.schema,
+
+  /** Accepts a hex string. */
+  EventSelector: EventSelector.schema,
+};
+
+export const AbiDecodedSchema: ZodFor<AbiDecoded> = z.union([
+  schemas.BigInt,
+  z.boolean(),
+  schemas.AztecAddress,
+  z.array(z.lazy(() => AbiDecodedSchema)),
+  z.record(z.lazy(() => AbiDecodedSchema)),
+]);
+
+export {
+  type ZodFor,
+  bufferSchema,
+  hexSchema,
+  hexSchemaFor,
+  bufferSchemaFor,
+  type ApiSchemaFor,
+  optional,
+  mapSchema,
+  pickFromSchema,
+} from '@aztec/foundation/schemas';

package/src/shared_mutable/index.ts

@@ -0,0 +1,4 @@
+export * from './scheduled_delay_change.js';
+export * from './scheduled_value_change.js';
+export * from './shared_mutable_values.js';
+export * from './shared_mutable_values_with_hash.js';

package/src/shared_mutable/scheduled_delay_change.ts

@@ -0,0 +1,13 @@
+import type { UInt32 } from '../types/shared.js';
+
+export class ScheduledDelayChange {
+  constructor(public pre: UInt32 | undefined, public post: UInt32 | undefined, public blockOfChange: UInt32) {}
+
+  static empty() {
+    return new this(undefined, undefined, 0);
+  }
+
+  isEmpty(): boolean {
+    return this.pre === undefined && this.post === undefined && this.blockOfChange === 0;
+  }
+}

package/src/shared_mutable/scheduled_value_change.ts

@@ -0,0 +1,25 @@
+import { Fr } from '@aztec/foundation/fields';
+
+export class ScheduledValueChange {
+  constructor(public previous: Fr[], public post: Fr[], public blockOfChange: number) {
+    if (this.previous.length !== this.post.length) {
+      throw new Error('Previous and post must have the same length');
+    }
+  }
+
+  static empty(valueSize: number) {
+    return new this(Array(valueSize).fill(new Fr(0)), Array(valueSize).fill(new Fr(0)), 0);
+  }
+
+  isEmpty(): boolean {
+    return this.previous.every(v => v.isZero()) && this.post.every(v => v.isZero()) && this.blockOfChange === 0;
+  }
+
+  getCurrentAt(blockNumber: number) {
+    if (blockNumber < this.blockOfChange) {
+      return this.previous;
+    } else {
+      return this.post;
+    }
+  }
+}

package/src/shared_mutable/shared_mutable_values.ts

@@ -0,0 +1,92 @@
+import { UPDATES_VALUE_SIZE } from '@aztec/constants';
+import { poseidon2Hash } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { ScheduledDelayChange } from './scheduled_delay_change.js';
+import { ScheduledValueChange } from './scheduled_value_change.js';
+
+export const SHARED_MUTABLE_VALUES_LEN = 2 * UPDATES_VALUE_SIZE + 1;
+
+export class SharedMutableValues {
+  constructor(public svc: ScheduledValueChange, public sdc: ScheduledDelayChange) {}
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+
+    const firstField = reader.readField().toBigInt();
+
+    // Extract fields for ScheduledValueChange
+    const svcPre = reader.readFieldArray(UPDATES_VALUE_SIZE);
+    const svcPost = reader.readFieldArray(UPDATES_VALUE_SIZE);
+    const svcBlockOfChange = firstField & 0xffffffffn;
+    const svc = new ScheduledValueChange(svcPre, svcPost, Number(svcBlockOfChange));
+
+    // Extract fields for ScheduledDelayChange from first field
+    const sdcBlockOfChange = (firstField >> 32n) & 0xffffffffn;
+    const sdcIsPostSome = (firstField >> 64n) & 1n;
+    const sdcPost = (firstField >> 72n) & 0xffffffffn;
+    const sdcIsPreSome = (firstField >> 104n) & 1n;
+    const sdcPre = (firstField >> 112n) & 0xffffffffn;
+
+    const sdc = new ScheduledDelayChange(
+      sdcIsPreSome ? Number(sdcPre) : undefined,
+      sdcIsPostSome ? Number(sdcPost) : undefined,
+      Number(sdcBlockOfChange),
+    );
+
+    return new this(svc, sdc);
+  }
+
+  toFields(): Fr[] {
+    // Pack format matches Noir implementation:
+    // [ sdc.pre_inner: u32 | sdc.pre_is_some: u8 | sdc.post_inner: u32 | sdc.post_is_some: u8 | sdc.block_of_change: u32 | svc.block_of_change: u32 ]
+    let firstField = BigInt(this.svc.blockOfChange);
+    firstField |= BigInt(this.sdc.blockOfChange) << 32n;
+    firstField |= (this.sdc.post === undefined ? 0n : 1n) << 64n;
+    firstField |= BigInt(this.sdc.post || 0) << 72n;
+    firstField |= (this.sdc.pre === undefined ? 0n : 1n) << 104n;
+    firstField |= BigInt(this.sdc.pre || 0) << 112n;
+
+    return [new Fr(firstField), ...this.svc.previous, ...this.svc.post];
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer(this.toFields());
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader, valueSize: number): SharedMutableValues {
+    const reader = BufferReader.asReader(buffer);
+    return SharedMutableValues.fromFields(reader.readArray(2 * valueSize + 1, Fr));
+  }
+
+  static empty(valueSize: number) {
+    return new this(ScheduledValueChange.empty(valueSize), ScheduledDelayChange.empty());
+  }
+
+  static async readFromTree(sharedMutableSlot: Fr, readStorage: (storageSlot: Fr) => Promise<Fr>) {
+    const fields = [];
+    for (let i = 0; i < SHARED_MUTABLE_VALUES_LEN; i++) {
+      fields.push(await readStorage(sharedMutableSlot.add(new Fr(i))));
+    }
+    return SharedMutableValues.fromFields(fields);
+  }
+
+  isEmpty(): boolean {
+    return this.svc.isEmpty() && this.sdc.isEmpty();
+  }
+
+  async writeToTree(sharedMutableSlot: Fr, storageWrite: (storageSlot: Fr, value: Fr) => Promise<void>) {
+    const fields = this.toFields();
+
+    for (let i = 0; i < fields.length; i++) {
+      await storageWrite(sharedMutableSlot.add(new Fr(i)), fields[i]);
+    }
+  }
+
+  async hash(): Promise<Fr> {
+    const fields = this.toFields();
+    const hash = await poseidon2Hash(fields);
+    return hash;
+  }
+}

package/src/shared_mutable/shared_mutable_values_with_hash.ts

@@ -0,0 +1,38 @@
+import { UPDATED_CLASS_IDS_SLOT } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+
+import type { AztecAddress } from '../aztec-address/index.js';
+import { deriveStorageSlotInMap } from '../hash/map_slot.js';
+import { ScheduledDelayChange } from './scheduled_delay_change.js';
+import { ScheduledValueChange } from './scheduled_value_change.js';
+import { SHARED_MUTABLE_VALUES_LEN, SharedMutableValues } from './shared_mutable_values.js';
+
+export class SharedMutableValuesWithHash {
+  private smv: SharedMutableValues;
+
+  constructor(svc: ScheduledValueChange, sdc: ScheduledDelayChange) {
+    this.smv = new SharedMutableValues(svc, sdc);
+  }
+
+  async toFields(): Promise<Fr[]> {
+    return [...this.smv.toFields(), await this.smv.hash()];
+  }
+
+  async writeToTree(sharedMutableSlot: Fr, storageWrite: (storageSlot: Fr, value: Fr) => Promise<void>) {
+    const fields = await this.toFields();
+
+    for (let i = 0; i < fields.length; i++) {
+      await storageWrite(sharedMutableSlot.add(new Fr(i)), fields[i]);
+    }
+  }
+
+  static async getContractUpdateSlots(contractAddress: AztecAddress) {
+    const sharedMutableSlot = await deriveStorageSlotInMap(new Fr(UPDATED_CLASS_IDS_SLOT), contractAddress);
+    const sharedMutableHashSlot = sharedMutableSlot.add(new Fr(SHARED_MUTABLE_VALUES_LEN));
+
+    return {
+      sharedMutableSlot,
+      sharedMutableHashSlot,
+    };
+  }
+}

package/src/stats/index.ts

@@ -0,0 +1 @@
+export * from './stats.js';

package/src/stats/stats.ts

@@ -0,0 +1,276 @@
+/** Stats associated with an ACIR proof generation.*/
+export type ProofConstructed = {
+  /** Name of the event for metrics purposes */
+  eventName: 'proof_construction_time';
+  /** Name of the program being proven */
+  acir_test: string;
+  /** Number of threads used for proving */
+  threads: number;
+  /** Time spent proving */
+  value: number;
+};
+
+/** Stats associated with an L2 block. */
+export type L2BlockStats = {
+  /** Number of txs in the L2 block. */
+  txCount: number;
+  /** Number of the L2 block. */
+  blockNumber: number;
+  /** Number of public logs. */
+  publicLogCount?: number;
+};
+
+/** Stats logged for each L1 publish tx.*/
+export type L1PublishStats = {
+  /** Address of the sender. */
+  sender: string;
+  /** Effective gas price of the tx. */
+  gasPrice: bigint;
+  /** Effective gas used in the tx. */
+  gasUsed: bigint;
+  /** Hash of the L1 tx. */
+  transactionHash: string;
+  /** Gas cost of the calldata. */
+  calldataGas: number;
+  /** Size in bytes of the calldata. */
+  calldataSize: number;
+  /** Gas cost of the blob data */
+  blobDataGas: bigint;
+  /** Amount of blob gas used. */
+  blobGasUsed: bigint;
+  /** Number of blobs in the tx */
+  blobCount?: number;
+  /** Number of L1 blocks between tx submission and inclusion */
+  inclusionBlocks?: number;
+};
+
+/** Stats logged for each L1 rollup publish tx.*/
+export type L1PublishBlockStats = {
+  /** Name of the event for metrics purposes */
+  eventName: 'rollup-published-to-l1';
+} & L1PublishStats &
+  L2BlockStats;
+
+/** Stats logged for each L1 rollup publish tx.*/
+export type L1PublishProofStats = {
+  /** Name of the event for metrics purposes */
+  eventName: 'proof-published-to-l1';
+} & L1PublishStats;
+
+/** Stats logged for synching node chain history.  */
+export type NodeSyncedChainHistoryStats = {
+  /** Name of the event. */
+  eventName: 'node-synced-chain-history';
+  /** Number of txs in the L2 block.. */
+  txCount: number;
+  /** Number of txs in each block. */
+  txsPerBlock: number;
+  /** Duration in ms. */
+  duration: number;
+  /** Id of the L2 block. */
+  blockNumber: number;
+  /** Number of blocks processed. */
+  blockCount: number;
+  /** Size of the db in bytes. */
+  dbSize: number;
+};
+
+export type ClientCircuitName =
+  | 'private-kernel-init'
+  | 'private-kernel-inner'
+  | 'private-kernel-reset'
+  | 'private-kernel-tail'
+  | 'private-kernel-tail-to-public'
+  | 'app-circuit';
+
+export type ServerCircuitName =
+  | 'base-parity'
+  | 'root-parity'
+  | 'private-base-rollup'
+  | 'public-base-rollup'
+  | 'merge-rollup'
+  | 'block-root-rollup'
+  | 'single-tx-block-root-rollup'
+  | 'empty-block-root-rollup'
+  | 'block-merge-rollup'
+  | 'root-rollup'
+  | 'avm-circuit'
+  | 'tube-circuit';
+
+export type CircuitName = ClientCircuitName | ServerCircuitName;
+
+/** Stats for circuit simulation. */
+export type CircuitSimulationStats = {
+  /** name of the event. */
+  eventName: 'circuit-simulation';
+  /** Name of the circuit. */
+  circuitName: CircuitName;
+  /** Optional. The function name that's being simulated */
+  appCircuitName?: string;
+  /** Duration in ms. */
+  duration: number;
+  /** Size in bytes of circuit inputs. */
+  inputSize: number;
+  /** Size in bytes of circuit outputs (aka public inputs). */
+  outputSize: number;
+};
+
+export type PublicDBAccessStats = {
+  eventName: 'public-db-access';
+  duration: number;
+  operation: string;
+};
+
+export type AvmSimulationStats = {
+  /** name of the event. */
+  eventName: 'avm-simulation';
+  /** Name of the circuit. */
+  appCircuitName: string;
+  /** Duration in ms. */
+  duration: number;
+};
+
+/** Stats for witness generation. */
+export type CircuitWitnessGenerationStats = {
+  /** name of the event. */
+  eventName: 'circuit-witness-generation';
+  /** Name of the circuit. */
+  circuitName: CircuitName;
+  /** Optional. The function name that's being proven */
+  appCircuitName?: string;
+  /** Duration in ms. */
+  duration: number;
+  /** Size in bytes of circuit inputs. */
+  inputSize: number;
+  /** Size in bytes of circuit outputs (aka public inputs). */
+  outputSize: number;
+};
+
+/** Stats for proving a circuit */
+export type CircuitProvingStats = {
+  /** Name of the event. */
+  eventName: 'circuit-proving';
+  /** Name of the circuit. */
+  circuitName: CircuitName;
+  /** Optional. The function name that was proven */
+  appCircuitName?: string;
+  /** Duration in ms. */
+  duration: number;
+  /** The size of the circuit (in gates) */
+  circuitSize: number;
+  /** Size in bytes of circuit inputs. */
+  inputSize: number;
+  /** Size in bytes of the proof. */
+  proofSize: number;
+  /** The number of public inputs */
+  numPublicInputs: number;
+};
+
+/** Stats for verifying a circuit */
+export type CircuitVerificationStats = {
+  /** Name of the event. */
+  eventName: 'circuit-verification';
+  /** Name of the circuit. */
+  circuitName: CircuitName;
+  /** Type of proof (client-ivc, honk, etc) */
+  proofType: 'client-ivc' | 'ultra-honk';
+  /** Duration in ms. */
+  duration: number;
+};
+
+/** Stats for an L2 block built by a sequencer. */
+export type L2BlockBuiltStats = {
+  /** The creator of the block */
+  creator: string;
+  /** Name of the event. */
+  eventName: 'l2-block-built';
+  /** Total duration in ms. */
+  duration: number;
+  /** Time for processing public txs in ms. */
+  publicProcessDuration: number;
+  /** Time for running rollup circuits in ms.  */
+  rollupCircuitsDuration: number;
+} & L2BlockStats;
+
+/** Stats for an L2 block processed by the world state synchronizer. */
+export type L2BlockHandledStats = {
+  /** Name of the event. */
+  eventName: 'l2-block-handled';
+  /** Total duration in ms. */
+  duration: number;
+  /** Pending block number. */
+  unfinalisedBlockNumber: bigint;
+  /** Proven block number. */
+  finalisedBlockNumber: bigint;
+  /** Oldest historic block number. */
+  oldestHistoricBlock: bigint;
+} & L2BlockStats;
+
+/** Stats for a tx. */
+export type TxStats = {
+  /** Hash of the tx. */
+  txHash: string;
+  /** Total size in bytes. */
+  size: number;
+  /** Size of the proof. */
+  proofSize: number;
+  /** Number of note hashes */
+  noteHashCount: number;
+  /** Number of nullifiers */
+  nullifierCount: number;
+  /** Number of private logs */
+  privateLogCount: number;
+  /** How many classes were registered through the canonical class registerer. */
+  classRegisteredCount: number;
+  /** Serialized size of contract class logs in fields. */
+  contractClassLogSize: number;
+  /** How this tx pays for its fee */
+  feePaymentMethod: 'fee_juice' | 'fpc_public' | 'fpc_private';
+};
+
+/**
+ * Stats for tree insertions
+ */
+export type TreeInsertionStats = {
+  /** Name of the event. */
+  eventName: 'tree-insertion';
+  /** Duration in ms. */
+  duration: number;
+  /** The size of the insertion batch */
+  batchSize: number;
+  /** The tree name */
+  treeName: string;
+  /** The tree depth */
+  treeDepth: number;
+  /** Tree type */
+  treeType: 'append-only' | 'indexed';
+  /** Number of hashes performed */
+  hashCount: number;
+  /** Average duration of a hash operation */
+  hashDuration: number;
+};
+
+/** A new tx was added to the tx pool. */
+export type TxAddedToPoolStats = {
+  /** Name of the event. */
+  eventName: 'tx-added-to-pool';
+} & TxStats;
+
+/** Stats emitted in structured logs with an `eventName` for tracking. */
+export type Stats =
+  | AvmSimulationStats
+  | CircuitProvingStats
+  | CircuitSimulationStats
+  | CircuitWitnessGenerationStats
+  | PublicDBAccessStats
+  | L1PublishBlockStats
+  | L1PublishProofStats
+  | L2BlockBuiltStats
+  | L2BlockHandledStats
+  | NodeSyncedChainHistoryStats
+  | ProofConstructed
+  | TreeInsertionStats
+  | TxAddedToPoolStats;
+
+/** Set of event names across emitted stats. */
+export type StatsEventName = Stats['eventName'];