@aztec/stdlib 0.0.1-commit.b655e406 → 0.0.1-commit.fce3e4f

package/src/tx/global_variables.ts

@@ -1,4 +1,6 @@
 import { GLOBAL_VARIABLES_LENGTH } from '@aztec/constants';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import { randomInt } from '@aztec/foundation/crypto';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
@@ -31,7 +33,7 @@ export class GlobalVariables {
     /** Block number of the L2 block. */
     public blockNumber: UInt32,
     /** Slot number of the L2 block */
-    public slotNumber: Fr,
+    public slotNumber: SlotNumber,
     /** Timestamp of the L2 block. */
     public timestamp: UInt64,
     /** Recipient of block reward. */
@@ -48,7 +50,7 @@ export class GlobalVariables {
         chainId: schemas.Fr,
         version: schemas.Fr,
         blockNumber: schemas.UInt32,
-        slotNumber: schemas.Fr,
+        slotNumber: schemas.SlotNumber,
         timestamp: schemas.BigInt,
         coinbase: schemas.EthAddress,
         feeRecipient: schemas.AztecAddress,
@@ -65,10 +67,30 @@ export class GlobalVariables {
     return new GlobalVariables(...GlobalVariables.getFields(fields));
   }
 
+  /**
+   * Creates a GlobalVariables 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 GlobalVariables fields
+   * @returns A GlobalVariables instance
+   */
+  static fromPlainObject(obj: any): GlobalVariables {
+    return new GlobalVariables(
+      Fr.fromPlainObject(obj.chainId),
+      Fr.fromPlainObject(obj.version),
+      obj.blockNumber,
+      SlotNumber(Fr.fromPlainObject(obj.slotNumber).toNumber()),
+      typeof obj.timestamp === 'bigint' ? obj.timestamp : BigInt(obj.timestamp),
+      EthAddress.fromPlainObject(obj.coinbase),
+      AztecAddress.fromPlainObject(obj.feeRecipient),
+      GasFees.fromPlainObject(obj.gasFees),
+    );
+  }
+
   static empty(fields: Partial<FieldsOf<GlobalVariables>> = {}): GlobalVariables {
     return GlobalVariables.from({
       blockNumber: 0,
-      slotNumber: Fr.ZERO,
+      slotNumber: SlotNumber.ZERO,
       timestamp: 0n,
       chainId: Fr.ZERO,
       version: Fr.ZERO,
@@ -85,7 +107,7 @@ export class GlobalVariables {
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
       reader.readNumber(),
-      Fr.fromBuffer(reader),
+      SlotNumber(reader.readNumber()),
       reader.readUInt64(),
       reader.readObject(EthAddress),
       reader.readObject(AztecAddress),
@@ -100,7 +122,7 @@ export class GlobalVariables {
       reader.readField(),
       reader.readField(),
       reader.readU32(),
-      reader.readField(),
+      SlotNumber(reader.readU32()),
       reader.readField().toBigInt(),
       EthAddress.fromField(reader.readField()),
       AztecAddress.fromField(reader.readField()),
@@ -151,13 +173,31 @@ export class GlobalVariables {
   toFriendlyJSON() {
     return {
       blockNumber: this.blockNumber,
-      slotNumber: this.slotNumber.toNumber(),
+      slotNumber: this.slotNumber,
       timestamp: this.timestamp.toString(),
       coinbase: this.coinbase.toString(),
       gasFees: jsonStringify(this.gasFees),
     };
   }
 
+  /**
+   * Converts GlobalVariables to a plain object suitable for MessagePack serialization.
+   * This method ensures that slotNumber is serialized as a Fr (Field element) to match
+   * the C++ struct definition which expects slot_number as FF.
+   */
+  toJSON() {
+    return {
+      chainId: this.chainId,
+      version: this.version,
+      blockNumber: this.blockNumber,
+      slotNumber: new Fr(this.slotNumber), // Convert to Fr for C++ compatibility
+      timestamp: this.timestamp,
+      coinbase: this.coinbase,
+      feeRecipient: this.feeRecipient,
+      gasFees: this.gasFees,
+    };
+  }
+
   clone(): GlobalVariables {
     return GlobalVariables.fromBuffer(this.toBuffer());
   }
@@ -167,7 +207,7 @@ export class GlobalVariables {
       this.chainId.isZero() &&
       this.version.isZero() &&
       this.blockNumber === 0 &&
-      this.slotNumber.isZero() &&
+      this.slotNumber === 0 &&
       this.timestamp === 0n &&
       this.coinbase.isZero() &&
       this.feeRecipient.isZero() &&
@@ -175,12 +215,26 @@ export class GlobalVariables {
     );
   }
 
+  static random(overrides: Partial<FieldsOf<GlobalVariables>> = {}): GlobalVariables {
+    return GlobalVariables.from({
+      chainId: new Fr(randomInt(100_000)),
+      version: new Fr(randomInt(100_000)),
+      blockNumber: randomInt(100_000),
+      slotNumber: SlotNumber(randomInt(100_000)),
+      coinbase: EthAddress.random(),
+      feeRecipient: AztecAddress.fromField(Fr.random()),
+      gasFees: GasFees.random(),
+      timestamp: BigInt(randomInt(100_000_000)),
+      ...overrides,
+    });
+  }
+
   toInspect() {
     return {
       chainId: this.chainId.toNumber(),
       version: this.version.toNumber(),
       blockNumber: this.blockNumber,
-      slotNumber: this.slotNumber.toNumber(),
+      slotNumber: this.slotNumber,
       timestamp: this.timestamp,
       coinbase: this.coinbase.toString(),
       feeRecipient: this.feeRecipient.toString(),
@@ -198,7 +252,7 @@ export class GlobalVariables {
       this.chainId.equals(other.chainId) &&
       this.version.equals(other.version) &&
       this.blockNumber === other.blockNumber &&
-      this.slotNumber.equals(other.slotNumber) &&
+      this.slotNumber === other.slotNumber &&
       this.timestamp === other.timestamp &&
       this.coinbase.equals(other.coinbase) &&
       this.feeRecipient.equals(other.feeRecipient) &&

package/src/tx/index.ts

@@ -31,3 +31,4 @@ 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';

package/src/tx/indexed_tx_effect.ts

@@ -13,7 +13,7 @@ export function indexedTxSchema() {
 
 export async function randomIndexedTxEffect(): Promise<IndexedTxEffect> {
   return {
-    ...randomInBlock(await TxEffect.random()),
+    ...randomInBlock(await TxEffect.random({ numNullifiers: 1 + Math.floor(Math.random() * 64) })),
     txIndexInBlock: Math.floor(Math.random() * 1000),
   };
 }

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 { 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,14 +64,6 @@ export class PartialStateReference {
     return new PartialStateReference(noteHashTree, nullifierTree, publicDataTree);
   }
 
-  static fromViem(stateReference: ViemPartialStateReference) {
-    return new PartialStateReference(
-      AppendOnlyTreeSnapshot.fromViem(stateReference.noteHashTree),
-      AppendOnlyTreeSnapshot.fromViem(stateReference.nullifierTree),
-      AppendOnlyTreeSnapshot.fromViem(stateReference.publicDataTree),
-    );
-  }
-
   static random(): PartialStateReference {
     return new PartialStateReference(
       AppendOnlyTreeSnapshot.random(),
@@ -72,14 +72,6 @@ export class PartialStateReference {
     );
   }
 
-  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

@@ -26,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,
   ) {}
@@ -35,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());
   }
 }
 

package/src/tx/profiling.ts

@@ -1,12 +1,10 @@
 import { Fr } from '@aztec/foundation/fields';
-import { type ZodFor, optional } from '@aztec/foundation/schemas';
+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[] }>>;
 
@@ -127,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

@@ -50,6 +50,22 @@ export class ProtocolContracts {
     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);
   }

package/src/tx/public_call_request_with_calldata.ts

@@ -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));
   }

package/src/tx/public_simulation_output.ts

@@ -7,6 +7,7 @@ import { z } from 'zod';
 import { SimulationError } from '../errors/simulation_error.js';
 import { Gas } from '../gas/gas.js';
 import type { GasUsed } from '../gas/gas_used.js';
+import { NullishToUndefined } from '../schemas/schemas.js';
 import { TxEffect } from '../tx/tx_effect.js';
 import { GlobalVariables } from './global_variables.js';
 
@@ -23,15 +24,31 @@ export class NestedProcessReturnValues {
     this.nested = nested ?? [];
   }
 
+  equals(other: NestedProcessReturnValues): boolean {
+    return (
+      this.values?.length === other.values?.length &&
+      this.nested.length === other.nested.length &&
+      (this.values === undefined || this.values.every((v, i) => v.equals(other.values![i]))) &&
+      this.nested.every((n, i) => n.equals(other.nested[i]))
+    );
+  }
+
   static get schema(): ZodFor<NestedProcessReturnValues> {
     return z
       .object({
-        values: z.array(schemas.Fr).optional(),
+        values: NullishToUndefined(z.array(schemas.Fr)),
         nested: z.array(z.lazy(() => NestedProcessReturnValues.schema)),
       })
       .transform(({ values, nested }) => new NestedProcessReturnValues(values, nested));
   }
 
+  static fromPlainObject(obj: any): NestedProcessReturnValues {
+    return new NestedProcessReturnValues(
+      obj.values?.map(Fr.fromPlainObject),
+      obj.nested?.map(NestedProcessReturnValues.fromPlainObject),
+    );
+  }
+
   static empty() {
     return new NestedProcessReturnValues([]);
   }

package/src/tx/state_reference.ts

@@ -4,9 +4,9 @@ import {
   NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
   STATE_REFERENCE_LENGTH,
 } from '@aztec/constants';
-import type { ViemStateReference } from '@aztec/ethereum';
 import type { Fr } from '@aztec/foundation/fields';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
 
 import { inspect } from 'util';
 import { z } from 'zod';
@@ -38,6 +38,14 @@ export class StateReference {
     return this.l1ToL2MessageTree.getSize() + this.partial.getSize();
   }
 
+  static getFields(fields: FieldsOf<StateReference>) {
+    return [fields.l1ToL2MessageTree, fields.partial] as const;
+  }
+
+  static from(fields: FieldsOf<StateReference>) {
+    return new StateReference(...StateReference.getFields(fields));
+  }
+
   toBuffer() {
     // Note: The order here must match the order in the ProposedHeaderLib solidity library.
     return serializeToBuffer(this.l1ToL2MessageTree, this.partial);
@@ -67,13 +75,6 @@ export class StateReference {
     return new StateReference(l1ToL2MessageTree, partial);
   }
 
-  static fromViem(stateReference: ViemStateReference) {
-    return new StateReference(
-      AppendOnlyTreeSnapshot.fromViem(stateReference.l1ToL2MessageTree),
-      PartialStateReference.fromViem(stateReference.partialStateReference),
-    );
-  }
-
   static empty(): StateReference {
     return new StateReference(AppendOnlyTreeSnapshot.empty(), PartialStateReference.empty());
   }
@@ -82,13 +83,6 @@ export class StateReference {
     return new StateReference(AppendOnlyTreeSnapshot.random(), PartialStateReference.random());
   }
 
-  toViem(): ViemStateReference {
-    return {
-      l1ToL2MessageTree: this.l1ToL2MessageTree.toViem(),
-      partialStateReference: this.partial.toViem(),
-    };
-  }
-
   toAbi(): [ReturnType<AppendOnlyTreeSnapshot['toAbi']>, ReturnType<PartialStateReference['toAbi']>] {
     return [this.l1ToL2MessageTree.toAbi(), [...this.partial.toAbi()]];
   }

package/src/tx/tree_snapshots.ts

@@ -91,6 +91,22 @@ export class TreeSnapshots {
     );
   }
 
+  /**
+   * Creates a TreeSnapshots 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 TreeSnapshots fields
+   * @returns A TreeSnapshots instance
+   */
+  static fromPlainObject(obj: any): TreeSnapshots {
+    return new TreeSnapshots(
+      AppendOnlyTreeSnapshot.fromPlainObject(obj.l1ToL2MessageTree),
+      AppendOnlyTreeSnapshot.fromPlainObject(obj.noteHashTree),
+      AppendOnlyTreeSnapshot.fromPlainObject(obj.nullifierTree),
+      AppendOnlyTreeSnapshot.fromPlainObject(obj.publicDataTree),
+    );
+  }
+
   isEmpty(): boolean {
     return (
       this.l1ToL2MessageTree.isEmpty() &&

package/src/tx/tx.ts

@@ -271,11 +271,12 @@ export class Tx extends Gossipable {
   /**
    * Clones a tx, making a deep copy of all fields.
    * @param tx - The transaction to be cloned.
+   * @param cloneProof - Whether to clone the proof as well. If false, will shallow copy.
    * @returns The cloned transaction.
    */
-  static clone(tx: Tx): Tx {
+  static clone(tx: Tx, cloneProof = true): Tx {
     const publicInputs = PrivateKernelTailCircuitPublicInputs.fromBuffer(tx.data.toBuffer());
-    const chonkProof = ChonkProof.fromBuffer(tx.chonkProof.toBuffer());
+    const chonkProof = cloneProof ? ChonkProof.fromBuffer(tx.chonkProof.toBuffer()) : tx.chonkProof;
     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, chonkProof, contractClassLogFields, publicFunctionCalldata);
@@ -317,13 +318,12 @@ export class Tx extends Gossipable {
  */
 export class TxArray extends Array<Tx> {
   static fromBuffer(buffer: Buffer | BufferReader): TxArray {
+    const reader = BufferReader.asReader(buffer);
     try {
-      const reader = BufferReader.asReader(buffer);
       const txs = reader.readVector(Tx);
-
       return new TxArray(...txs);
     } catch {
-      return new TxArray();
+      throw new Error('Failed to deserialize TxArray from buffer');
     }
   }